lunch_and_learn.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Vector Spaces\n",
    "* What is a vector?\n",
    "    * Vectors are not lists of numbers (necessarily)\n",
    "* Children have an intuitive idea of what vectors are\n",
    "* A first definition of a vector\n",
    "    * Vectors are a quantity with direction and length\n",
    "    * Examples: 5 meters (length) to your left (direction). 20 miles (length) north (direction)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "slideshow": {
     "slide_type": "skip"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ac1d97c780594b58ae7ff8679cf9c080",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(IntSlider(value=180, description='angle', max=360, step=10), Output()), _dom_classes=('w…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "from matplotlib import pyplot as plt \n",
    "import matplotlib as mpl\n",
    "import numpy as np\n",
    "from ipywidgets import interact\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "from matplotlib.patches import ConnectionPatch\n",
    "\n",
    "def create_func_vis(num_funcs=1):\n",
    "    fig, axs = plt.subplots(1, num_funcs+1)\n",
    "    for ax in axs:\n",
    "        ax.set_xlim(-2, 2)\n",
    "        ax.set_ylim(-2, 2)\n",
    "        ax.set_xticks([])\n",
    "        ax.set_yticks([])\n",
    "        ax.set_aspect('equal', adjustable='box')\n",
    "    for i in range(num_funcs):\n",
    "        con = ConnectionPatch(xyA=(0,0), xyB=(0,0), coordsA=\"data\", coordsB=\"data\", axesA=axs[i], axesB=axs[i+1], arrowstyle=\"->\", alpha=0.5)\n",
    "        axs[i+1].add_artist(con)\n",
    "    return fig, axs\n",
    "\n",
    "def plot_vec(x, y, u, v, ax=plt, **kwargs):\n",
    "    return ax.quiver(x, y, u, v, angles='xy', units=\"xy\", scale=1, scale_units=\"xy\", **kwargs)\n",
    "\n",
    "def plot_vec3(x, y, z, u, v, w, **kwargs):\n",
    "    return plt.quiver(x, y, z, u, v, w, **kwargs)\n",
    "\n",
    "def plot_vec_at_origin(vecs: np.ndarray, color='black', ax=plt):\n",
    "    if len(vecs.shape) == 1:\n",
    "        vecs = vecs.reshape(1, 2)\n",
    "    o = np.zeros(vecs.shape[0])\n",
    "    return ax.quiver(o, o, vecs[:, 0], vecs[:, 1], color=color, angles='xy', units=\"xy\", scale=1, scale_units=\"xy\")\n",
    "\n",
    "def plot_vec3_at_origin(ax, vecs: np.ndarray, color='black'):\n",
    "    if len(vecs.shape) == 1:\n",
    "        vecs = vecs.reshape(1, 3)\n",
    "    o = np.zeros(vecs.shape[0])\n",
    "    return ax.quiver(o, o, o, vecs[:, 0], vecs[:, 1], vecs[:, 2], color=color)\n",
    "\n",
    "def rotation(theta):\n",
    "    c, s = np.cos(np.radians(theta)), np.sin(np.radians(theta))\n",
    "    return np.array(((c, -s), (s, c)))\n",
    "\n",
    "def get_vec(angle, length):\n",
    "    return rotation(angle)@np.array((length,0))\n",
    "\n",
    "@interact(angle=(0, 360, 10))\n",
    "def demonstrate_no_coord_grid(angle):\n",
    "    plt.xlim(-2, 2)\n",
    "    plt.ylim(-2, 2)\n",
    "    plt.axis('off')\n",
    "    plt.gca().set_aspect('equal', adjustable='box')\n",
    "    rot = rotation(angle)\n",
    "    vecs = np.array((rot @ np.array([1, 1]), rot @ np.array([0, -1])))\n",
    "    plot_vec_at_origin(vecs)\n",
    "    plt.plot(0, 0, 'o', color=\"black\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* Coordinate grids are extra structure that we will add in shortly. They are not necessarily part of vectors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* Because vectors have a length, they can be scaled up or down by an arbitrary real number\n",
    "    * Negative scaling corresponds to opposite direction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "slideshow": {
     "slide_type": "skip"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8bdea20f4c65493b92c9b66b8816e431",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(FloatSlider(value=0.0, description='len', max=2.0, min=-2.0), Output()), _dom_classes=('…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "@interact(len=(-2, 2, 0.1))\n",
    "def demonstrate_scaling(len):\n",
    "    plt.xlim(-2, 2)\n",
    "    plt.ylim(-2, 2)\n",
    "    plt.axis('off')\n",
    "    plt.gca().set_aspect('equal', adjustable='box')\n",
    "    vecs = len * np.array([1, 1])\n",
    "    plot_vec_at_origin(vecs)\n",
    "    plt.plot(0, 0, 'o', color=\"black\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* Vectors can also be added together. \n",
    "    * Adding a vector $a$ to a vector $b$ produces a new vector $a+b$ by putting the tail of the second vector at the tip of the first vector\n",
    "    * This can be done in either order, producing a sort of parallelogram\n",
    "        * This is called the commutative law\n",
    "    * Example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "slideshow": {
     "slide_type": "skip"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Control the angle and size of the red arrow\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3769250bd83b49b6a5061731b4802502",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(IntSlider(value=180, description='angle', max=360, step=10), FloatSlider(value=1.0, desc…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(\"Control the angle and size of the red arrow\")\n",
    "@interact(angle=(0, 360, 10), length=(0.1, 2, 0.1))\n",
    "def demonstrate_vector_addition(angle, length):\n",
    "    plt.figure()\n",
    "    plt.xlim(-2, 2)\n",
    "    plt.ylim(-2, 2)\n",
    "    plt.axis('off')\n",
    "    plt.gca().set_aspect('equal', adjustable='box')\n",
    "    rot = rotation(angle)\n",
    "    vecs = np.array((get_vec(angle, length), [1, 1]))\n",
    "    plot_vec_at_origin(vecs, color=['red', \"blue\"])\n",
    "    plot_vec_at_origin(vecs[0]+vecs[1])\n",
    "    plot_vec(vecs[:, 0], vecs[:, 1], vecs[::-1, 0], vecs[::-1, 1], color=[\"blue\", 'red'])\n",
    "    plt.plot(0, 0, 'o', color=\"black\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* There are other operations on vectors I won't be covering in detail today\n",
    "    * Dot product, cross product, tensor product, outer product, clifford product, determinant, etc...\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* I claim that anything which has an addition and a scaling operation can be thought of as a vector\n",
    "    * In other words, given a real number, like $\\pi=3.1415\\dots$, you must be able to form the vector $\\pi v$\n",
    "    * And you must be able to add $u$ to $v$ to get $u+v$\n",
    "    * Anything with these two operations we will call a **vector space**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* Some examples:\n",
    "    * The set of arrows in the 2d plane, without any coordinate grid forms a vector space as we saw above\n",
    "    * The set of lists of 3 numbers, called $\\mathbb{R}^3$ is a vector space\n",
    "    $$\\begin{bmatrix}1 \\\\2 \\\\3\\end{bmatrix} +\\begin{bmatrix}4 \\\\5 \\\\6\\end{bmatrix} =\\begin{bmatrix}5 \\\\7 \\\\9\\end{bmatrix}$$\n",
    "    \n",
    "    * More generally, the set of lists of $n$ numbers is called $\\mathbb{R}^n$\n",
    "    * The set of polynomials in a single variable is a vector space\n",
    "        $(x^2+2x+3)+(4x^2+5x+6)=5x^2+7x+9$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Linear Independence, Span, and Bases\n",
    "* Now that we have a working definition of a vector (an element of some vector space), we can begin to introduce coordinate grids to things in the form of a basis\n",
    "* In order to define a basis we need to define some other terms first"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* Linear combinations\n",
    "    * A linear combination of a set of vectors is a sum of the vectors, each with a scale factor applied.\n",
    "    * A linear combination of the vectors $u$ and $v$ is written as $au+by$.\n",
    "    * An example of a linear combination of vectors in $\\mathbb{R}^3$:\n",
    "    $$3\\begin{bmatrix}1 \\\\0 \\\\0\\end{bmatrix} +2\\begin{bmatrix}0 \\\\1 \\\\0\\end{bmatrix} +5\\begin{bmatrix}0\\\\0\\\\1\\end{bmatrix}=\\begin{bmatrix}3 \\\\2 \\\\5\\end{bmatrix}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "* Linear independence\n",
    "    * A set of vectors is **linearly independent** if it contains no redundant vectors\n",
    "    * In other words, no vector in the set can be written as a linear combination of the others\n",
    "    * Examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "slideshow": {
     "slide_type": "skip"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOcAAADnCAYAAADl9EEgAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAD90lEQVR4nO3ZvaqcZRiG0efdiYS0Bm3TiMbC1kIEmzSKOQNzMJ6Klb0eQrSxCKncIIIIKioItgp50wQMok324HdlXKuZn+ou5uJhZtbee4Cei6MHAP9MnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBLnGVlr3VhrraN3cBriPC8fzMwbR4/gNK4fPYCTujczr83M5dFDuLq19z56Ayew1rqYmZ9m5nLv/d7Re7g6l/N8vD0zr87MrbXWy3vv344exNX4znk+Pnz6eG1m3j9yCKchzvNx71+e84LynfMMrLVuz8x3z7z1+8y8svf+85hFnILLeR7uzMz9mfl5Zr6cmY/HXyovPJfzjKy1fpiZr/fed4/ewtW5nBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEicJa6231lovHb2jRJxU3J2ZX9dan661Plpr3Tp60NHW3vvoDZzIWuvHmbkxMw+P3vIcbs7MO8+8fjwzX8zMZzPz+cxc7v/Zh/X60QM4qXdn5sHMvHn0kOdw7W+vL2bm9Zm5MzPfzMy3M/PHfz3qSC4nCWut+zPzycw8mr+u5Vd778eHDjuQy0nFLzNze+/9/dFDKlxOiPJrLUSJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IegL6qk6NbQ0bRgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOcAAADnCAYAAADl9EEgAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAEvklEQVR4nO3YvapcVQCG4W/lRyGVKBE7SxtJKYhFGsEfTGWnYO0dBK/AxkKwSauFla2VlZ3WRrSxDHZeQFCWxTlIxMScnz2zv9nzPDDMsKuvmHfPmj3mnAH6XFl7APB44oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4oRS4tyQMcazY4yx9o6ljTGujzFurL1j38S5Le8meWXtEUsZJ95P8k2Sh2vv2Tdxbsud09fBG2PcTvJDTsL8cs7558qT9m7MOdfewALGGFeS/J7k1znn7bX3XNQY41aST3NyCkiSH5O8Po/wi3pt7QEs5rUkLyZ5YYzx/Jzzj7UHnccY45kknyf5OMmj/5vvHmOYiWPtlrx3+n41yTtrDrmIOefDJHeT/PzI5W/nnN+vNGl14tyOO0/4fBDGGFeT3EvyapL7SWaST1YdtTJxbsAY4+Uktx659PYY4/pae87rNMyvknyQ5OskbyS5N+f8adVhK/NAaAPGGG8luZnksyS/5eQJ53dzzvurDjuDx4T50ZzzrzHGM6dH3aMlzg0ZYzxI8suc8821t5zFk8Jcd1UPx1pWIcynEyd7J8yzESd7JcyzEyd7I8zzESd7IczzEyc7J8yLESc7JcyLEyc7I8zLESc7IczLEyeLE+YyxMmihLkccbIYYS5LnCxCmMsTJ5cmzN0QJ5cizN0RJxcmzN0SJxcizN0TJ+cmzP0QJ+cizP0RJ2cmzP0SJ2cizP0TJ08lzHWIk/8lzPWIkycS5rrEyWMJc33i5D+E2UGc/Iswe4iTfwizizhJIsxG4kSYpcR55ITZS5xHTJjdxHmkhNlPnEdImIdBnEdGmIdDnEdEmIdFnEdCmIdHnEdAmIdJnBsnzMMlzg0T5mET50YJ8/CJc4OEuQ3i3CZhbsCYc669gYWMMR7k5Ib7UoR58K6tPYBF3UjyXIS5CX45N2SMcTPJh0m+EObhEyeU8kAISokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSv0NFtR4E7jTtlIAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def demonstrate_linear_independence_1():\n",
    "    plt.figure()\n",
    "    plt.xlim(-2, 2)\n",
    "    plt.ylim(-2, 2)\n",
    "    plt.axis('off')\n",
    "    plt.gca().set_aspect('equal', adjustable='box')\n",
    "    vecs = np.array(((1,0), (0, 1)))\n",
    "    plot_vec_at_origin(vecs)\n",
    "    return plt.gcf()\n",
    "demonstrate_linear_independence_1()\n",
    "\n",
    "def demonstrate_linear_independence_2():\n",
    "    plt.figure()\n",
    "    plt.xlim(-2, 2)\n",
    "    plt.ylim(-2, 2)\n",
    "    plt.axis('off')\n",
    "    plt.gca().set_aspect('equal', adjustable='box')\n",
    "    vecs = np.array(((1,1), (0, 1)))\n",
    "    plot_vec_at_origin(vecs)\n",
    "    return plt.gcf()\n",
    "demonstrate_linear_independence_2()\n",
    "\n",
    "def demonstrate_linear_independence_3():\n",
    "    fig = plt.figure()\n",
    "    ax = fig.add_subplot(111, projection='3d')\n",
    "    ax.set_xlim([-2, 2])\n",
    "    ax.set_ylim([-2, 2])\n",
    "    ax.set_zlim([-2, 2])\n",
    "    plot_vec3_at_origin(ax, np.array(((0, 1, 0), (1,0,0), (0, 0, 1))))\n",
    "    return fig\n",
    "demonstrate_linear_independence_3();\n",
    "\n",
    "def demonstrate_linear_independence_4():\n",
    "    fig = plt.figure()\n",
    "    ax = fig.add_subplot(111, projection='3d')\n",
    "    ax.set_xlim([-2, 2])\n",
    "    ax.set_ylim([-2, 2])\n",
    "    ax.set_zlim([-2, 2])\n",
    "    plot_vec3_at_origin(ax, np.array(((0, 1, 1), (1,0,0), (0, 0, 1))))\n",
    "    return fig\n",
    "demonstrate_linear_independence_4();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "* A set of vectors is linearly dependent if it contains extra, redundant vectors\n",
    "    * In other words, some vector can be written as a linear combination of the other vectors\n",
    "    * Examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "slideshow": {
     "slide_type": "skip"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOcAAADnCAYAAADl9EEgAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAD8ElEQVR4nO3YvYpeVRSA4bVnjKaKf2lkiGKVQpxGvAMJXoClXoeNpVdiZWGnNrGTVAmCRrCxiERiYSwEIURhciyioDKgjuN8b+B54BS7WLAOnJcNZ23bNkDP3q4XAI4nTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDhJWGteXmvO7XqPU7fW87PWxZOMipOK12bm7lrz/lrz5lrz7K4XOiXbzNyeta7NWm/PWi/NWuufDK5t2/7n3Tgr76x3L12dK5/veo+TuD/n97+cwyd/P+/N0RzOzR+vzNUf3pgP7r4yn93bm0f2W311Zi784XxrZj787fl0tu2X44YeO4PFOCPbrHPfzqWndr3HSRzN/p/OD2Z/7szBhTtz8PitefGZw7l5/4k59ht+FJz/y/lgZi7PzNcz89XMfHfckJuThLXmrZl5b2a+mIc3ykczc2Pb5sFOF/uv1np6Zr6ZmZ9n5uN5+G6fzLb99Hejbk4qvp+ZF7Ztbu96kVP23My8PjPXZ9uO/s2gmxOi/K2FKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVG/ArIWS/DPxJa6AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def demonstrate_linear_dependence_1():\n",
    "    plt.figure()\n",
    "    plt.xlim(-2, 2)\n",
    "    plt.ylim(-2, 2)\n",
    "    plt.axis('off')\n",
    "    plt.gca().set_aspect('equal', adjustable='box')\n",
    "    vecs = np.array(((2,0), (1,0)))\n",
    "    plot_vec_at_origin(vecs, color=[\"red\", \"blue\"])\n",
    "    return plt.gcf()\n",
    "demonstrate_linear_dependence_1();\n",
    "\n",
    "def demonstrate_linear_dependence_2():\n",
    "    plt.figure()\n",
    "    plt.xlim(-2, 2)\n",
    "    plt.ylim(-2, 2)\n",
    "    plt.axis('off')\n",
    "    plt.gca().set_aspect('equal', adjustable='box')\n",
    "    vecs = np.array((get_vec(0, 1), [1, 1]))\n",
    "    plot_vec_at_origin(vecs)\n",
    "    plot_vec_at_origin(vecs[0]+vecs[1])\n",
    "    plt.plot(0, 0, 'o', color=\"black\")\n",
    "demonstrate_linear_dependence_2();\n",
    "\n",
    "def demonstrate_linear_dependence_3():\n",
    "    fig = plt.figure()\n",
    "    ax = fig.add_subplot(111, projection='3d')\n",
    "    ax.set_xlim([-2, 2])\n",
    "    ax.set_ylim([-2, 2])\n",
    "    ax.set_zlim([-2, 2])\n",
    "    plot_vec3_at_origin(ax, np.array(((1, 1, 0), (1,0,0), (0, 1, 0))))\n",
    "    return fig\n",
    "demonstrate_linear_dependence_3();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "* Span\n",
    "    * The next notion we need to define is that of a span of a set of vectors\n",
    "    * Every vector in the plane can be written as a linear combination of the following two vectors:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "slideshow": {
     "slide_type": "skip"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOcAAADnCAYAAADl9EEgAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAD90lEQVR4nO3ZvaqcZRiG0efdiYS0Bm3TiMbC1kIEmzSKOQNzMJ6Klb0eQrSxCKncIIIIKioItgp50wQMok324HdlXKuZn+ou5uJhZtbee4Cei6MHAP9MnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBLnGVlr3VhrraN3cBriPC8fzMwbR4/gNK4fPYCTujczr83M5dFDuLq19z56Ayew1rqYmZ9m5nLv/d7Re7g6l/N8vD0zr87MrbXWy3vv344exNX4znk+Pnz6eG1m3j9yCKchzvNx71+e84LynfMMrLVuz8x3z7z1+8y8svf+85hFnILLeR7uzMz9mfl5Zr6cmY/HXyovPJfzjKy1fpiZr/fed4/ewtW5nBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEicJa6231lovHb2jRJxU3J2ZX9dan661Plpr3Tp60NHW3vvoDZzIWuvHmbkxMw+P3vIcbs7MO8+8fjwzX8zMZzPz+cxc7v/Zh/X60QM4qXdn5sHMvHn0kOdw7W+vL2bm9Zm5MzPfzMy3M/PHfz3qSC4nCWut+zPzycw8mr+u5Vd778eHDjuQy0nFLzNze+/9/dFDKlxOiPJrLUSJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IegL6qk6NbQ0bRgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "demonstrate_linear_independence_1();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Next we demonstrate why this happens. \n",
    "    * Note how you can stretch the blue and red vectors to reach any vector on the plane:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "slideshow": {
     "slide_type": "skip"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a8586fe4644f428aa35725387eabce5d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(FloatSlider(value=0.0, description='l1', max=2.0, min=-2.0), FloatSlider(value=0.0, desc…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "@interact(l1=(-2, 2, 0.1), l2=(-2, 2, 0.1))\n",
    "def demonstrate_span(l1, l2):\n",
    "    plt.figure()\n",
    "    plt.xlim(-2, 2)\n",
    "    plt.ylim(-2, 2)\n",
    "    plt.axis('off')\n",
    "    plt.gca().set_aspect('equal', adjustable='box')\n",
    "    vec1 = l1 * np.array((1,0))\n",
    "    vec2 = l2 * np.array((1,1))\n",
    "    plot_vec_at_origin(vec1, color='red')\n",
    "    plot_vec(vec1[0], vec1[1], vec2[0], vec2[1], color=\"blue\")\n",
    "    plt.plot(0, 0, 'o', color=\"black\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "* Given a set of vectors, the set of all linear combinations of those vectors is called the **span** of that set\n",
    "* Example:\n",
    "    * The span of the two vectors visualized on the next slide is the entire green plane"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "slideshow": {
     "slide_type": "skip"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4574a556e10e4e5987eb2db5fc3bad62",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(IntSlider(value=40, description='angle', max=80, step=10), Output()), _dom_classes=('wid…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "@interact(angle=(0, 80, 10))\n",
    "def demonstrate_span(angle):\n",
    "    vec1 = np.array((1, 0, 0))\n",
    "    vec2 = np.array((0, np.cos(np.radians(angle)), np.sin(np.radians(angle))))\n",
    "    normal = np.cross(vec1, vec2)\n",
    "    x, y = np.meshgrid(np.arange(-2, 2, 0.1), np.arange(-2, 2, 0.1))\n",
    "    z = (-normal[0] * x - normal[1] * y) * 1. /normal[2]\n",
    "    fig = plt.figure()\n",
    "    ax = fig.add_subplot(111, projection='3d')\n",
    "    ax.set_xlim([-2, 2])\n",
    "    ax.set_ylim([-2, 2])\n",
    "    ax.set_zlim([-2, 2])\n",
    "    # display(np.stack(vec1, vec2))\n",
    "    plot_vec3_at_origin(ax, np.stack((vec1, vec2)))\n",
    "    art = ax.plot_surface(x, y, z, color = 'g')\n",
    "    art.set_alpha(0.5)\n",
    "    return fig"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "* Basis\n",
    "    * If a set of vectors is linearly independent, then it is said to be the basis for its span\n",
    "    * We say that a basis is a linearly independent spanning set\n",
    "    * Examples:\n",
    "        * The two vectors above are a basis for the green plane\n",
    "        * Any of the examples of linearly independent sets are also basis for the plane/space"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "* Rephrasing the definition:\n",
    "    * A set of vectors is a basis for a vector space if *every vector* can be written *uniquely* as a linear combination of the basis vectors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "* A stray definition\n",
    "    * We won't use this definition today, but the number of vectors in every basis of a vector space is the same\n",
    "    * This number is called the dimension of the vector space\n",
    "    * The dimension of the vector space of arrows in the plane is 2, as you would expect\n",
    "    * The dimension of $\\mathbb{R}^n$ is $n$, as you would expect\n",
    "    * The dimension of the set of all polynomials is infinite\n",
    "        * Basis: $1, x, x^2, x^3, x^4, x^5, \\dots$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "* All of this together shows us that there are a lot of different bases for the same vector space\n",
    "    * Bases are arbitrary, and our vector space of arrows doesn't come with a default choice\n",
    "    * $\\mathbb{R}^3$ does come with a canonical choice of basis though:\n",
    "        $$\\begin{bmatrix}1 \\\\0 \\\\0\\end{bmatrix},\\begin{bmatrix}0 \\\\1 \\\\0\\end{bmatrix},\\begin{bmatrix}0\\\\0\\\\1\\end{bmatrix}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "# Linear transformations\n",
    "- Recall the definition of a function in math:\n",
    "    - a function $f$ takes a vector $v$ and produces an output vector $f(v)$. The vector it produces is always the same given the same input vector\n",
    "    - Functions have a **domain** and a **codomain**, representing the vector spaces that the input and output are in.\n",
    "    - If the input space is $V$ and the output space is $W$ we write this as $f: V \\to W$. We read this as \"f is a function from V to W\".\n",
    "- A linear transform is a function satisfying an additional property: linearity\n",
    "    - Preservation of addition: $f(u+v)=f(u)+f(v)$\n",
    "    - Preservation of scaling: $f(cv)=cf(v)$\n",
    "- Linearity is sort of like the distributive law and commutative law combined.\n",
    "- Examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "slideshow": {
     "slide_type": "skip"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ce6ca8e69f824e3c89dfe66ac26b9f33",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(FloatSlider(value=0.0, description='l1', max=2.0, min=-2.0), FloatSlider(value=0.0, desc…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5ff181af232f477da50c1d0e915dc186",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(FloatSlider(value=0.0, description='l1', max=2.0, min=-2.0), FloatSlider(value=0.0, desc…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c06cc5299097462581e383c32d03d3ca",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(FloatSlider(value=0.0, description='l1', max=2.0, min=-2.0), FloatSlider(value=0.0, desc…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "18d5c5dd81ba459588e33baae6718d1d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(FloatSlider(value=0.0, description='l1', max=2.0, min=-2.0), FloatSlider(value=0.0, desc…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "@interact(l1=(-2, 2, 0.1), l2=(-2, 2, 0.1))\n",
    "def demonstrate_linear_transform_1(l1, l2):\n",
    "    fig, ax = create_func_vis()\n",
    "    vec1 = l1 * np.array((1,0.5))\n",
    "    vec2 = l2 * np.array((1,1))\n",
    "    plot_vec_at_origin(vec1, color='red', ax=ax[0])\n",
    "    plot_vec(vec1[0], vec1[1], vec2[0], vec2[1], color=\"blue\", ax=ax[0])\n",
    "    ax[0].plot(0, 0, 'o', color=\"black\")\n",
    "\n",
    "    vec1 = 2 * vec1\n",
    "    vec2 = 2 * vec2\n",
    "\n",
    "    plot_vec_at_origin(vec1, color='red', ax=ax[1])\n",
    "    plot_vec(vec1[0], vec1[1], vec2[0], vec2[1], color=\"blue\", ax=ax[1])\n",
    "    ax[1].plot(0, 0, 'o', color=\"black\")\n",
    "\n",
    "@interact(l1=(-2, 2, 0.1), l2=(-2, 2, 0.1))\n",
    "def demonstrate_linear_transform_2(l1, l2):\n",
    "    fig, ax = create_func_vis()\n",
    "    vec1 = l1 * np.array((1,0.5))\n",
    "    vec2 = l2 * np.array((1,1))\n",
    "    plot_vec_at_origin(vec1, color='red', ax=ax[0])\n",
    "    plot_vec(vec1[0], vec1[1], vec2[0], vec2[1], color=\"blue\", ax=ax[0])\n",
    "    ax[0].plot(0, 0, 'o', color=\"black\")\n",
    "\n",
    "    rot = rotation(30)\n",
    "    vec1 = rot @ vec1\n",
    "    vec2 = rot @ vec2\n",
    "\n",
    "    plot_vec_at_origin(vec1, color='red', ax=ax[1])\n",
    "    plot_vec(vec1[0], vec1[1], vec2[0], vec2[1], color=\"blue\", ax=ax[1])\n",
    "    ax[1].plot(0, 0, 'o', color=\"black\")\n",
    "\n",
    "@interact(l1=(-2, 2, 0.1), l2=(-2, 2, 0.1))\n",
    "def demonstrate_linear_transform_3(l1, l2):\n",
    "    fig, ax = create_func_vis()\n",
    "    vec1 = l1 * np.array((1,0))\n",
    "    vec2 = l2 * np.array((0,1))\n",
    "    plot_vec_at_origin(vec1, color='red', ax=ax[0])\n",
    "    plot_vec(vec1[0], vec1[1], vec2[0], vec2[1], color=\"blue\", ax=ax[0])\n",
    "    ax[0].plot(0, 0, 'o', color=\"black\")\n",
    "\n",
    "    skew = np.array(((1,0), (1,1))).T\n",
    "    vec1 = skew @ vec1\n",
    "    vec2 = skew @ vec2\n",
    "\n",
    "    plot_vec_at_origin(vec1, color='red', ax=ax[1])\n",
    "    plot_vec(vec1[0], vec1[1], vec2[0], vec2[1], color=\"blue\", ax=ax[1])\n",
    "    ax[1].plot(0, 0, 'o', color=\"black\")\n",
    "\n",
    "@interact(l1=(-2, 2, 0.1), l2=(-2, 2, 0.1))\n",
    "def demonstrate_linear_transform_4(l1, l2):\n",
    "    fig, ax = create_func_vis()\n",
    "    vec1 = l1 * np.array((1,0))\n",
    "    vec2 = l2 * np.array((0,1))\n",
    "    plot_vec_at_origin(vec1, color='red', ax=ax[0])\n",
    "    plot_vec(vec1[0], vec1[1], vec2[0], vec2[1], color=\"blue\", ax=ax[0])\n",
    "    ax[0].plot(0, 0, 'o', color=\"black\")\n",
    "\n",
    "    ref = np.array(((-1,0), (0,1))).T\n",
    "    vec1 = ref @ vec1\n",
    "    vec2 = ref @ vec2\n",
    "\n",
    "    plot_vec_at_origin(vec1, color='red', ax=ax[1])\n",
    "    plot_vec(vec1[0], vec1[1], vec2[0], vec2[1], color=\"blue\", ax=ax[1])\n",
    "    ax[1].plot(0, 0, 'o', color=\"black\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "- Freshman's dream\n",
    "    - A common error by young or inexperience mathematical discipuli is to assume a nonlinear operation is linear. As an example:\n",
    "    - assuming $(x+y)^n=x^n+y^n$\n",
    "- Why is linearity important?\n",
    "    - Lots of reasons: first of all a lot of important functions are linear\n",
    "        - Rotations\n",
    "        - Scaling\n",
    "        - Skewing\n",
    "        - Reflections\n",
    "    - Second of all, they are simpler to deal with, as we shall soon see\n",
    "    - Third, many functions can be approximated by linear functions. Ask if you want further details on this"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "- Composition of linear functions\n",
    "    - Given any two functions, $f$ and $g$, you can form the composition of them: $f(g(v))$.\n",
    "    - This means, first apply the transform $g$, then apply the transform $f$ to the output of it\n",
    "    - Note that in order for functions to be composable their domains and codomains must match up like $f: V \\to W$ and $g: U \\to V$\n",
    "    - The composition of two linear functions is linear:\n",
    "        $$\\begin{align}f(g(au+bv))&=f(g(au)+g(bv))\\\\&= f(ag(u)+bg(v)) \\\\&= af(g(u))+bf(g(v))\\end{align}$$\n",
    "    - Examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "slideshow": {
     "slide_type": "skip"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a131776763124063b4f3d288af2237fb",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(FloatSlider(value=0.0, description='l1', max=2.0, min=-2.0), FloatSlider(value=0.0, desc…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "@interact(l1=(-2, 2, 0.1), l2=(-2, 2, 0.1))\n",
    "def demonstrate_composition(l1, l2):\n",
    "    fig, ax = create_func_vis(num_funcs=2)\n",
    "    vec1 = l1 * np.array((1,0))\n",
    "    vec2 = l2 * np.array((0,1))\n",
    "\n",
    "    plot_vec_at_origin(vec1, color='red', ax=ax[0])\n",
    "    plot_vec(vec1[0], vec1[1], vec2[0], vec2[1], color=\"blue\", ax=ax[0])\n",
    "    ax[0].plot(0, 0, 'o', color=\"black\")\n",
    "\n",
    "    rot = rotation(30)\n",
    "    vec1 = rot @ vec1\n",
    "    vec2 = rot @ vec2\n",
    "\n",
    "    plot_vec_at_origin(vec1, color='red', ax=ax[1])\n",
    "    plot_vec(vec1[0], vec1[1], vec2[0], vec2[1], color=\"blue\", ax=ax[1])\n",
    "    ax[1].plot(0, 0, 'o', color=\"black\")\n",
    "\n",
    "    skew = np.array(((1,0), (1,1))).T\n",
    "    vec1 = skew @ vec1\n",
    "    vec2 = skew @ vec2\n",
    "\n",
    "    plot_vec_at_origin(vec1, color='red', ax=ax[2])\n",
    "    plot_vec(vec1[0], vec1[1], vec2[0], vec2[1], color=\"blue\", ax=ax[2])\n",
    "    ax[2].plot(0, 0, 'o', color=\"black\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "- Isomorphism\n",
    "    - If every vector in the codomain comes from a unique vector in the domain, we call this an isomorphism\n",
    "    - Equivalently, an isomorphism is an invertible linear transform: \n",
    "        - There exists an inverse function $f^{-1}$ such that $f(f^{-1}(v))=v$\n",
    "    - Example: \n",
    "        - The inverse of a 30 deg rotation is a -30 deg rotation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "slideshow": {
     "slide_type": "skip"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2a05a17451dc47e0b4e238f1e744d677",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(FloatSlider(value=0.0, description='l1', max=2.0, min=-2.0), FloatSlider(value=0.0, desc…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "@interact(l1=(-2, 2, 0.1), l2=(-2, 2, 0.1))\n",
    "def demonstrate_inverse(l1, l2):\n",
    "    fig, ax = create_func_vis(num_funcs=2)\n",
    "    vec1 = l1 * np.array((1,0))\n",
    "    vec2 = l2 * np.array((0,1))\n",
    "\n",
    "    plot_vec_at_origin(vec1, color='red', ax=ax[0])\n",
    "    plot_vec(vec1[0], vec1[1], vec2[0], vec2[1], color=\"blue\", ax=ax[0])\n",
    "    ax[0].plot(0, 0, 'o', color=\"black\")\n",
    "\n",
    "    rot = rotation(30)\n",
    "    vec1 = rot @ vec1\n",
    "    vec2 = rot @ vec2\n",
    "\n",
    "    plot_vec_at_origin(vec1, color='red', ax=ax[1])\n",
    "    plot_vec(vec1[0], vec1[1], vec2[0], vec2[1], color=\"blue\", ax=ax[1])\n",
    "    ax[1].plot(0, 0, 'o', color=\"black\")\n",
    "\n",
    "    rot = rotation(-30)\n",
    "    vec1 = rot @ vec1\n",
    "    vec2 = rot @ vec2\n",
    "\n",
    "    plot_vec_at_origin(vec1, color='red', ax=ax[2])\n",
    "    plot_vec(vec1[0], vec1[1], vec2[0], vec2[1], color=\"blue\", ax=ax[2])\n",
    "    ax[2].plot(0, 0, 'o', color=\"black\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "- A choice of a basis for a vector space is the same as choosing an isomorphism to $\\mathbb{R}^n$ (where $n$ is the dimension).\n",
    "    - We can think of this function as assigning coordinates to every vector in our domain\n",
    "    - Example:\n",
    "        - Assign the vectors $\\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix}, \\begin{bmatrix} 0 \\\\ 1 \\end{bmatrix}$ to the basis below"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "slideshow": {
     "slide_type": "skip"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOcAAADnCAYAAADl9EEgAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAD90lEQVR4nO3ZvaqcZRiG0efdiYS0Bm3TiMbC1kIEmzSKOQNzMJ6Klb0eQrSxCKncIIIIKioItgp50wQMok324HdlXKuZn+ou5uJhZtbee4Cei6MHAP9MnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBLnGVlr3VhrraN3cBriPC8fzMwbR4/gNK4fPYCTujczr83M5dFDuLq19z56Ayew1rqYmZ9m5nLv/d7Re7g6l/N8vD0zr87MrbXWy3vv344exNX4znk+Pnz6eG1m3j9yCKchzvNx71+e84LynfMMrLVuz8x3z7z1+8y8svf+85hFnILLeR7uzMz9mfl5Zr6cmY/HXyovPJfzjKy1fpiZr/fed4/ewtW5nBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEicJa6231lovHb2jRJxU3J2ZX9dan661Plpr3Tp60NHW3vvoDZzIWuvHmbkxMw+P3vIcbs7MO8+8fjwzX8zMZzPz+cxc7v/Zh/X60QM4qXdn5sHMvHn0kOdw7W+vL2bm9Zm5MzPfzMy3M/PHfz3qSC4nCWut+zPzycw8mr+u5Vd778eHDjuQy0nFLzNze+/9/dFDKlxOiPJrLUSJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IegL6qk6NbQ0bRgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "demonstrate_linear_independence_1();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "# Matrices\n",
    "- Matrices are to basis as coordinates are to vector spaces\n",
    "- Linear transforms are uniquely determined by their value on a basis\n",
    "    - **Very Important**\n",
    "    - Proof:\n",
    "        - Let $x_1, x_2$ be a basis\n",
    "        - Every vector $v$ can be written as $v=ax_1+bx_2$\n",
    "            - We know this is possible since $x_1, x_2$ is a basis\n",
    "        - Now, $f(v)=af(x_1)+bf(x_2)$ \n",
    "    - Therefore we can define any linear transform by just listing what the output of the basis vectors should be\n",
    "        - So, if $f(x_1)=x_3$ and $f(x_2)=x_4$ then we write the linear transform as just $[x_3, x_4]$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "- Remember that choosing a basis gives vectors coordinates\n",
    "- If we choose a basis, we can write the output vectors in that basis\n",
    "- So, if, in coordinates, $x_3=\\begin{bmatrix}2 \\\\ 3 \\end{bmatrix}$ and $x_4=\\begin{bmatrix} 1 \\\\ 2 \\end{bmatrix}$\n",
    "    - then our matrix becomes $\\begin{bmatrix} 2 & 1 \\\\ 3 & 2 \\end{bmatrix}$\n",
    "- If we work soley in $\\mathbb{R}^n$ then there is another way to say this:\n",
    "    - The first column of the matrix is the output of $\\begin{bmatrix}1\\\\0\\end{bmatrix}$ under the linear transform\n",
    "    - The second column of the matrix is the output of $\\begin{bmatrix}0\\\\1\\end{bmatrix}$ under the linear transform"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "- Composition of linear transforms corresponds to matrix multiplication\n",
    "    - I won't go through all the details, but\n",
    "    - If you have two linear transforms, both of which have the same domain and codomain, then you may choose a basis and get a matrix for each of them\n",
    "    - You may compose them, you get another linear transform\n",
    "        - Hence, the composition has a matrix too\n",
    "    - If you work through the details of this, it turns out that the matrix of the composition corresponds to the matrix multiplication of the matrices of the two transforms\n",
    "    - Example:\n",
    "        - Suppose we want to compose the linear transform whose matrix is $\\begin{bmatrix} 2 & 1 \\\\ 3 & 2 \\end{bmatrix}$ with $\\begin{bmatrix} 3 & 7 \\\\ 1 & 1 \\end{bmatrix}$\n",
    "        - Well, we know that $\\begin{bmatrix} 1\\\\0\\end{bmatrix}$ goes to $\\begin{bmatrix} 2 \\\\ 3 \\end{bmatrix}$\n",
    "        - And we know that $\\begin{bmatrix} 2 \\\\ 3 \\end{bmatrix}$ goes to $2\\begin{bmatrix} 3\\\\1 \\end{bmatrix}+3\\begin{bmatrix} 7 \\\\ 1 \\end{bmatrix}$\n",
    "        - Hence the top left entry is $2*3+3*7$\n",
    "            - But this is the same as what you get when you matrix multiply the above two matrices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "- To be continued:\n",
    "  - Further topics\n",
    "    - Change of basis formula\n",
    "    - Gauss-Jordan\n",
    "    - Inner products, orthonormality\n",
    "    - Gram-Schimdt\n",
    "      - Interpolation formula for quaternions\n",
    "    - The first isomorphism theorem for inner product spaces\n",
    "    - Eigenvalues\n",
    "    - Determinants\n",
    "    - Duality\n",
    "    - Tensors\n",
    "  - Further material\n",
    "    - [Essense of linear algebra](https://www.youtube.com/playlist?list=PLZHQObOWTQDPD3MizzM2xVFitgF8hE_ab) by 3blue1brown\n",
    "    - Linear algebra done right by Axler\n",
    "    - http://number-none.com/product/Understanding%20Slerp,%20Then%20Not%20Using%20It/"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  },
  "metadata": {
   "interpreter": {
    "hash": "0600588c3b5f4418cbe7b5ebc6825b479f3bc010269d8b60d75058cdd010adfe"
   }
  },
  "toc-showtags": true
 },
 "nbformat": 4,
 "nbformat_minor": 4
}