psets/pset2/PS2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Problem set 2 (145 pts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem 1 (LU decomposition) 25 pts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. LU for band matrices (7 pts)\n",
    "\n",
    "The complexity to find an LU decomposition of a dense $n\\times n$ matrix is $\\mathcal{O}(n^3)$.\n",
    "Significant reduction in complexity can be achieved if the matrix has a certain structure, e.g. it is sparse. \n",
    "In the following task we consider an important example of $LU$ for a special type of sparse matrices –– band matrices with the bandwidth $m$ equal to 3 or 5 which called tridiagonal and pentadiagonal respectively.\n",
    "\n",
    "- (5 pts) Write a function ```band_lu(diag_broadcast, n)``` which computes LU decomposition for tridiagonal or pentadiagonal matrix with given diagonal values. \n",
    "For example, input parametres ```(diag_broadcast = [4,-2,1], n = 4)``` mean that we need to find LU decomposition for the triangular matrix of the form:\n",
    "\n",
    "$$A = \\begin{pmatrix}\n",
    "-2 & 1 & 0 & 0\\\\\n",
    "4 & -2 & 1 & 0 \\\\\n",
    "0 & 4 & -2 & 1 \\\\\n",
    "0 & 0 & 4 & -2 \\\\\n",
    "\\end{pmatrix}.$$\n",
    "\n",
    "As an output it is considered to make ```L``` and ```U``` - 2D arrays representing diagonals in factors $L$ (```L[0]``` keeps first lower diagonal, ```L[1]``` keeps second lower, ...), and $U$ (```U[:,0]``` keeps main diagonal, ```U[:,1]``` keeps first upper, ...).\n",
    "- (2 pts) Compare execution time of the band LU decomposition using standard function from ```scipy```, i.e. which takes the whole matrix and does not know about its special structure, and band decomposition of yours implementation. Comment on the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.sparse import diags # can be used with broadcasting of scalars if desired dimensions are large\n",
    "import numpy as np\n",
    "\n",
    "# INPUT : diag_broadcast - list of diagonals value to broadcast,length equal to 3 or 5; n - integer, band matrix shape.\n",
    "# OUTPUT : L - 2D np.ndarray, L.shape[0] depends on bandwidth, L.shape[1] = n-1, do not store main diagonal, where all ones;                  add zeros to the right side of rows to handle with changing length of diagonals.\n",
    "#          U - 2D np.ndarray, U.shape[0] = n, U.shape[1] depends on bandwidth;\n",
    "#              add zeros to the bottom of columns to handle with changing length of diagonals.\n",
    "def band_lu(diag_broadcast, n):\n",
    "    if n <= 0:\n",
    "        raise ValueError\n",
    "    if len(diag_broadcast) == 3:\n",
    "        a, b, c = diag_broadcast\n",
    "        f = [b]\n",
    "        for _ in range(n - 1):\n",
    "            try:\n",
    "                f.append(b - a / f[-1] * c)\n",
    "            except ZeroDivisionError:\n",
    "                raise ValueError('LU decomposition does not exist!')\n",
    "        f = np.array(f)\n",
    "        L = np.diag(a / f[:n - 1], -1)\n",
    "        np.fill_diagonal(L, 1)\n",
    "        U = np.diag(np.ones(n - 1) * c, 1)\n",
    "        np.fill_diagonal(U, f)\n",
    "    elif len(diag_broadcast) == 5:\n",
    "        a, b, c, d, e = diag_broadcast\n",
    "        L = [[0] * (n - 1)] * 2\n",
    "        U = [[0] * n, [0] * n, [e] * n]\n",
    "        U[0][0] = c\n",
    "        U[1][0] = d\n",
    "        for k in range(1, n):\n",
    "            L[1][k - 1] = a / U[0][k - 1]\n",
    "            L[0][k - 1] = (b - L[1][k - 2] * U[1][k - 2]) / U[0][k - 1]\n",
    "            U[1][k] = d - L[0][k - 1] * U[2][k - 1]\n",
    "            U[0][k] = c - L[0][k - 1] * U[1][k - 1] - L[1][k - 2] * U[2][k - 2]\n",
    "        L = np.diag(L[0], -1) + np.diag(L[1][:-1], -2)\n",
    "        np.fill_diagonal(L, 1)\n",
    "        U_diag = U[0].copy()\n",
    "        U = np.diag(U[1][:-1], 1) + np.diag(U[2][:-2], 2)\n",
    "        np.fill_diagonal(U, U_diag)\n",
    "    else:\n",
    "        raise NotImplementedError\n",
    "        \n",
    "    return L, U"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I decided to reconstruct the matrices right in the function. Otherwise, it is unfair to compare our LU with scipy LU, because the last one returns full matrices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-2.,  5.,  0.,  0.,  0.],\n",
       "       [ 4., -2.,  5.,  0.,  0.],\n",
       "       [ 0.,  4., -2.,  5.,  0.],\n",
       "       [ 0.,  0.,  4., -2.,  5.],\n",
       "       [ 0.,  0.,  0.,  4., -2.]])"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diag_broadcast = (4, -2, 5)\n",
    "L, U = band_lu(diag_broadcast, 5)\n",
    "L @ U"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [],
   "source": [
    "from time import time\n",
    "from scipy import linalg\n",
    "\n",
    "our_time = []\n",
    "scipy_time = []\n",
    "n_grid = [100, 500, 1000, 2500, 5000]\n",
    "for n in n_grid:\n",
    "    start = time()\n",
    "    L, U = band_lu(diag_broadcast, n)\n",
    "    our_time.append(time() - start)\n",
    "    A = L @ U\n",
    "    start = time()\n",
    "    P, L, U = linalg.lu(A)\n",
    "    scipy_time.append(time() - start)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "plt.figure(figsize=(10, 7))\n",
    "plt.plot(n_grid, our_time, label='band_lu')\n",
    "plt.plot(n_grid, scipy_time, label='scipy.linalg.lu')\n",
    "plt.xlabel('n', fontsize=13)\n",
    "plt.ylabel('Time elapsed, s', fontsize=13)\n",
    "plt.legend(fontsize=13);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Scipy LU shows quadratic dependency, meanwhile, time elapsed by band_lu is a linear function of $n$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Stability of LU (8 pts)\n",
    "\n",
    "Let\n",
    "$A = \\begin{pmatrix}\n",
    "\\varepsilon & 1 & 0\\\\\n",
    "1 & 1 & 1 \\\\\n",
    "0 & 1 & 1\n",
    "\\end{pmatrix}.$ \n",
    "* (5 pts) Find analytically LU decomposition with and without pivoting for the matrix $A$.\n",
    "* (3 pts) Explain, why can the LU decomposition fail to approximate factors $L$ and $U$ for $|\\varepsilon|\\ll 1$ in computer arithmetic?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\\begin{pmatrix}\n",
    "\\varepsilon & 1 & 0\\\\\n",
    "1 & 1 & 1 \\\\\n",
    "0 & 1 & 1\n",
    "\\end{pmatrix}\n",
    "\\sim \\begin{pmatrix}\n",
    "\\varepsilon & 1 & 0\\\\\n",
    "\\varepsilon & \\varepsilon & \\varepsilon \\\\\n",
    "0 & 1 & 1\n",
    "\\end{pmatrix}\n",
    "\\sim \\begin{pmatrix}\n",
    "\\varepsilon & 1 & 0\\\\\n",
    "0 & \\varepsilon - 1 & \\varepsilon \\\\\n",
    "0 & 1 & 1\n",
    "\\end{pmatrix}\n",
    "\\sim \\begin{pmatrix}\n",
    "\\varepsilon & 1 & 0\\\\\n",
    "0 & 1 & \\frac{\\varepsilon}{\\varepsilon - 1} \\\\\n",
    "0 & 1 & 1\n",
    "\\end{pmatrix}\n",
    "\\sim \\begin{pmatrix}\n",
    "\\varepsilon & 1 & 0\\\\\n",
    "0 & 1 & \\frac{\\varepsilon}{\\varepsilon - 1} \\\\\n",
    "0 & 0 & \\frac{1}{1 - \\varepsilon}\n",
    "\\end{pmatrix}\n",
    "\\sim \\begin{pmatrix}\n",
    "\\varepsilon & 1 & 0\\\\\n",
    "0 & \\varepsilon - 1 & \\varepsilon \\\\\n",
    "0 & 0 & 1\n",
    "\\end{pmatrix} = U$$ \n",
    "\n",
    "$$\n",
    "\\begin{pmatrix}\n",
    "\\varepsilon & 1 & 0\\\\\n",
    "1 & 1 & 1 \\\\\n",
    "0 & 1 & 1\n",
    "\\end{pmatrix}\n",
    "= \\begin{pmatrix}\n",
    "l_{11} & 0 & 0\\\\\n",
    "l_{21} & l_{22} & 0 \\\\\n",
    "l_{31} & l_{32} & l_{33}\n",
    "\\end{pmatrix}\n",
    "\\times \\begin{pmatrix}\n",
    "\\varepsilon & 1 & 0\\\\\n",
    "0 & \\varepsilon - 1 & \\varepsilon \\\\\n",
    "0 & 0 & 1\n",
    "\\end{pmatrix}\n",
    "\\Rightarrow L = \\begin{pmatrix}\n",
    "1 & 0 & 0\\\\\n",
    "\\frac{1}{\\varepsilon} & \\frac{1}{\\varepsilon} & 0 \\\\\n",
    "0 & \\frac{1}{1 - \\varepsilon} & \\frac{1}{1 - \\varepsilon}\n",
    "\\end{pmatrix}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consider an example of multiplying the second row of L by the second column of U:\n",
    "$$\\frac{1}{\\varepsilon} \\cdot 1 + \\frac{1}{\\varepsilon} \\cdot (\\varepsilon - 1) + 0 \\cdot 0 = \\frac{1}{\\varepsilon} + \\frac{\\varepsilon - 1}{\\varepsilon} = 1$$\n",
    "But due to limited machine precision $\\varepsilon - 1 \\approx -1$, which results in $\\frac{1}{\\varepsilon} - \\frac{1}{\\varepsilon} = 0$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eps = 1e-20\n",
    "1 / eps + (eps - 1) / eps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eps = 1e-10\n",
    "1 / eps + (eps - 1) / eps"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pivoting allows to avoid messing with $\\varepsilon$, in particular to drop divisions of type $\\frac{n\\varepsilon + \\text{smth}}{n\\varepsilon + \\text{smth}}$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$P = \\begin{pmatrix}\n",
    "0 & 1 & 0\\\\\n",
    "0 & 0 & 1 \\\\\n",
    "1 & 0 & 0\n",
    "\\end{pmatrix}\n",
    "\\Rightarrow PA =\n",
    "\\begin{pmatrix}\n",
    "1 & 1 & 1 \\\\\n",
    "0 & 1 & 1 \\\\\n",
    "\\varepsilon & 1 & 0\n",
    "\\end{pmatrix}$$\n",
    "$$\n",
    "\\begin{pmatrix}\n",
    "1 & 1 & 1 \\\\\n",
    "0 & 1 & 1 \\\\\n",
    "\\varepsilon & 1 & 0\n",
    "\\end{pmatrix}\n",
    "\\sim \\begin{pmatrix}\n",
    "1 & 1 & 1 \\\\\n",
    "0 & 1 & 1 \\\\\n",
    "\\varepsilon & 0 & -1\n",
    "\\end{pmatrix}\n",
    "\\sim \\begin{pmatrix}\n",
    "1 & 1 & 1 \\\\\n",
    "0 & 1 & 1 \\\\\n",
    "-1 & 0 & \\frac{1}{\\varepsilon}\n",
    "\\end{pmatrix}\n",
    "\\sim \\begin{pmatrix}\n",
    "1 & 1 & 1 \\\\\n",
    "0 & 1 & 1 \\\\\n",
    "0 & 0 & \\frac{1}{\\varepsilon}\n",
    "\\end{pmatrix}\n",
    "\\Rightarrow \\begin{pmatrix}\n",
    "1 & 1 & 1 \\\\\n",
    "0 & 1 & 1 \\\\\n",
    "\\varepsilon & 1 & 0\n",
    "\\end{pmatrix}\n",
    "= \\begin{pmatrix}\n",
    "1 & 0 & 0 \\\\\n",
    "0 & 1 & 0 \\\\\n",
    "\\varepsilon & 1 - \\varepsilon & -\\varepsilon\n",
    "\\end{pmatrix}\n",
    "\\times \\begin{pmatrix}\n",
    "1 & 1 & 1 \\\\\n",
    "0 & 1 & 1 \\\\\n",
    "0 & 0 & \\frac{1}{\\varepsilon}\n",
    "\\end{pmatrix}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here division happens only while computing $(PA)_{33}$, but it is immediately compensated: $-\\varepsilon \\cdot \\frac{1}{\\varepsilon} = -1$ independently on the machine precision."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [],
   "source": [
    "eps = 1e-20\n",
    "PA = np.array([\n",
    "    [1, 1, 1],\n",
    "    [0, 1, 1],\n",
    "    [eps, 1, 0]\n",
    "])\n",
    "L = np.array([\n",
    "    [1, 0, 0],\n",
    "    [0, 1, 0],\n",
    "    [eps, 1 - eps, -eps]\n",
    "])\n",
    "U = np.array([\n",
    "    [1, 1, 1],\n",
    "    [0, 1, 1],\n",
    "    [0, 0, 1 / eps]\n",
    "])\n",
    "\n",
    "assert np.isclose(L @ U, PA).all()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Block LU (10 pts)\n",
    "\n",
    "Let $A = \\begin{bmatrix} A_{11} & A_{12} \\\\ A_{21} & A_{22} \\end{bmatrix}$ be a block matrix. The goal is to solve the linear system\n",
    "\n",
    "$$\n",
    "     \\begin{bmatrix} A_{11} & A_{12} \\\\ A_{21} & A_{22} \\end{bmatrix} \\begin{bmatrix} u_1 \\\\ u_2 \\end{bmatrix} = \\begin{bmatrix} f_1 \\\\ f_2 \\end{bmatrix}.\n",
    "$$\n",
    "\n",
    "* (2 pts) Using block elimination find matrix $S$ and right-hand side $\\hat{f_2}$ so that $u_2$ can be found from $S u_2 = \\hat{f_2}$. Note that the matrix $S$ is called <font color='red'> Schur complement </font> of the block $A_{11}$.\n",
    "* (4 pts) Using Schur complement properties prove that \n",
    "\n",
    "$$\\det(X+AB) = \\det(X)\\det(I+BX^{-1}A), $$\n",
    "\n",
    "\n",
    "where $X$ - nonsingular square matrix.\n",
    "* (4 pts) Let matrix $F \\in \\mathbb{R}^{m \\times n}$ and $G \\in \\mathbb{R}^{n \\times m}$. Prove that \n",
    "\n",
    "$$\\det(I_m - FG) = \\det(I_n - GF).$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Lets multiply matrix A from the left-hand side by the following block matrix, where $X$ and $Y$ are block matrices of the matching size, to gain some zero blocks in the right-hand side:\n",
    "  \n",
    "  $$\\begin{pmatrix}\n",
    "  I & X\\\\\n",
    "  Y & I \n",
    "  \\end{pmatrix} \\cdot\n",
    "  \\begin{pmatrix}\n",
    "  A_{11} & A_{12}\\\\\n",
    "  A_{21} & A_{22} \n",
    "  \\end{pmatrix} =\n",
    "  \\begin{pmatrix}\n",
    "  P_{11} & P_{12}\\\\\n",
    "  0 & P_{22} \n",
    "  \\end{pmatrix}$$\n",
    "  \n",
    "  Thus, $Y = -A_{21} A_{11}^{-1}$. For $u_2$ from the folowing equation:\n",
    "  \n",
    "  $$\\begin{pmatrix}\n",
    "  I & X\\\\\n",
    "  Y & I \n",
    "  \\end{pmatrix} \\cdot\n",
    "  \\begin{pmatrix}\n",
    "  A_{11} & A_{12}\\\\\n",
    "  A_{21} & A_{22} \n",
    "  \\end{pmatrix} \\cdot\n",
    "  \\begin{pmatrix}\n",
    "  u_1\\\\\n",
    "  u_2 \n",
    "  \\end{pmatrix} =\n",
    "  \\begin{pmatrix}\n",
    "  I & X\\\\\n",
    "  Y & I \n",
    "  \\end{pmatrix} \\cdot\n",
    "  \\begin{pmatrix}\n",
    "  f_1\\\\\n",
    "  f_2 \n",
    "  \\end{pmatrix}$$\n",
    "\n",
    "  $$(Y \\times A_{12} + A_{22})u_2 = Y f_1 + f_2$$\n",
    "\n",
    "  Therefore, matrix $S$ is\n",
    "  $$S = -A_{21} A_{11}^{-1} A_{22} + A_{22},$$\n",
    "  \n",
    "  and vector $\\hat{f_2}$\n",
    "  \n",
    "  $$\\hat{f_2} = -A_{21} A_{11}^{-1}f_1 + f_2$$\n",
    "  \n",
    "\n",
    "* Let's look at eigenvalues of both $FG$ and $I_{m} - FG$\n",
    "  $$\\exists x \\ne 0: FGx = \\lambda x \\Rightarrow (I_{m} - FG)x = (1-\\lambda)x$$\n",
    "  \n",
    "  It means that for every eigenvalue $\\lambda$ of $FG$ there exists eigenvalue $(1 - \\lambda)$ of $I_{m} - FG$ and vice versa. Moreover, if $FGx = \\lambda x \\Rightarrow GFGx = \\lambda Gx$, therefore, $Gx$ is an eigenvector of $GF$ with the same eigenvalue, which means that non-zero eigenvalues of $FG$ and $GF$ are the same.\n",
    "  \n",
    "  To sum up: we have two matrices $FG$ and $GF$ with the same non-zero eigenvalues $\\lambda_1 \\dots \\lambda_r$, thus, matrices $I_m - FG$ and $I_n - GF$ have $1 - \\lambda_1 \\dots 1 - \\lambda_r$ among their eigenvalues complemented by some quantity of ones. As the determinant of a matrix is a product of its eigenvalues, both determinants equal to $\\prod_{i=1}^{r} (1 - \\lambda_i)$, which proves their equality.\n",
    "  \n",
    "  \n",
    "* From the previous point: $det(X + AB) = det(X) \\cdot det(I + X^{-1}AB) = det(X) \\cdot det(I + BX^{-1}A)$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "## Problem 2 (QR decomposition) 30 pts\n",
    "\n",
    "### 1. Standard Gram-Schmidt algorithm (18 pts)\n",
    "Our goal is to orthogonalize a system of linearly independent vectors $v_1,\\dots,v_n$.\n",
    "The standard algorithm for this task is the Gram-Schmidt process:\n",
    "\n",
    "$$\n",
    "\\begin{split}\n",
    "u_1 &= v_1, \\\\\n",
    "u_2 &= v_2 - \\frac{(v_2, u_1)}{(u_1, u_1)} u_1, \\\\\n",
    "\\dots \\\\\n",
    "u_n &= v_n - \\frac{(v_n, u_1)}{(u_1, u_1)} u_1 - \\frac{(v_n, u_2)}{(u_2, u_2)} u_2 - \\dots - \\frac{(v_n, u_{n-1})}{(u_{n-1}, u_{n-1})} u_{n-1}.\n",
    "\\end{split}\n",
    "$$\n",
    "\n",
    "Obtained $u_1, \\dots, u_n$ are orthogonal vectors in exact arithmetics. Then to make the system orthonormal you should divide each of the vectors by its norm: $u_i := u_i/\\|u_i\\|$.\n",
    "The Gram-Schmidt process can be considered as a QR decomposition. Let us show that."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* (2 pts) Write out what is matrices $Q$ and $R$ obtained in the process above. \n",
    "\n",
    "* (5 pts) Implement the described Gram-Schmidt algorithm as a function ```gram_schmidt_qr(A)``` that takes a rectangular matrix ```A``` and outputs ```Q,R```.\n",
    "\n",
    "* (3 pts) Create a rectangular matrix $K = [x, Ax, A^2x, \\ldots, A^kx]$ where $A \\in \\mathbb{R}^{100 \\times 100}$ is a random matrix and $x$ is a random vector of the appropriate dimension, $k = 20$.  \n",
    "The loss of orthogonality can be described by the following error: $\\|Q^{\\top}Q-I\\|_2$, where $Q^{\\top}Q$ is called a Gram matrix. Compute QR decomposition of the created matrix $K$ with function that you have implemented and calculate error $\\|Q^{\\top}Q-I\\|_2$. Comment on the result.\n",
    "\n",
    "* (5 pts) The observed loss of orthogonality is a problem of this particular algorithm. Luckily, there is [a simple improvement to the algorithm above](https://en.wikipedia.org/wiki/Gram–Schmidt_process#Numerical_stability) that reduces the loss of orthogonality. Implement this modification as a function ```modified_gram_schmidt_qr(A)``` such that input and output are similar to ```gram_schmidt_qr(A)```. \n",
    "* (3 pts) Compute QR decomposition of the matrix $K$ from the previous task with the function ```modified_gram_schmidt_qr(A)```.\n",
    "Compute error $\\|Q^{\\top}Q-I\\|_2$. Compare this error to the error obtained with a \"pure\" Gram-Schmidt and comment on the result."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$Q_{ij} = A_{ij} - \\sum_{k=1}^{j - 1}\\Big[\\Big(\\sum_p Q_{pk}Q_{pk}\\Big)^{-1}\\Big(\\sum_p A_{pk}Q_{pk}\\Big)Q_{ik}\\Big]$$\n",
    "$$R_{ij} = \\sum_{k=1}^n Q_{ki} A_{kj}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "metadata": {},
   "outputs": [],
   "source": [
    "# INPUT : rectangular matrix A\n",
    "# OUTPUT: matrices Q - orthogonal and R - upper triangular such that A = QR\n",
    "def gram_schmidt_qr(A): # 5 pts\n",
    "    Q = A.copy()\n",
    "    for j in range(A.shape[1]):\n",
    "        for i in range(j):\n",
    "            Q[:, j] -= np.dot(Q[:, i], A[:, j]) * Q[:, i]\n",
    "        Q[:, j] /= np.linalg.norm(Q[:, j])\n",
    "    return Q, np.matmul(Q.T, A)\n",
    "\n",
    "# INPUT : rectangular matrix A\n",
    "# OUTPUT: matrices Q - orthogonal and R - upper triangular such that A = QR\n",
    "def modified_gram_schmidt_qr(A): # 5 pts\n",
    "    Q = A.copy()\n",
    "    for j in range(A.shape[1]):\n",
    "        for i in range(j):\n",
    "            Q[:, j] -= np.dot(Q[:, i], Q[:, j]) * Q[:, i]\n",
    "        Q[:, j] /= np.linalg.norm(Q[:, j])\n",
    "    return Q, np.matmul(Q.T, A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 219,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.random.randn(50, 50)\n",
    "Q, R = gram_schmidt_qr(A)\n",
    "np.isclose(Q @ R, A).all()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 220,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.random.randn(50, 50)\n",
    "Q, R = modified_gram_schmidt_qr(A)\n",
    "np.isclose(Q @ R, A).all()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 221,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(100, 20)"
      ]
     },
     "execution_count": 221,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.random.rand(100, 100)\n",
    "columns = [np.random.randn(100, 1)]\n",
    "for _ in range(19):\n",
    "    columns.append(A @ columns[-1])\n",
    "K = np.hstack(columns)\n",
    "K.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10.765071073185888"
      ]
     },
     "execution_count": 222,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Q, R = gram_schmidt_qr(K)\n",
    "np.linalg.norm(Q.T @ Q - np.eye(Q.shape[1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.5928365871724006"
      ]
     },
     "execution_count": 223,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Q, R = modified_gram_schmidt_qr(K)\n",
    "np.linalg.norm(Q.T @ Q - np.eye(Q.shape[1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The loss of orthogonality decreased by 7 times!\n",
    "$Q^TQ$, a Gram matrix of coloumns of Q, in orthonormal case should have been identity matrix, but in vanilla Gram-Schmidt algorithm rounding errors were accumulating during the orthogonalization process and significantly affected orthogonality of the resulting column vectors. The modified Gram-Schmidt algorithm processes vectors alternatively $-$ instead of extracting components of other vectors in one subtraction, the algorithm does it sequentially, mantaining orhogonality to all previous vectors on each step."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Updating QR decompositions (12 pts)\n",
    "\n",
    "Suppose we are dealing with overdetermined system:\n",
    "\n",
    "$$ Ax = y, \\;\\; A \\in \\mathbb{R}^{m \\times n}, \\;\\;  m \\geq n. $$\n",
    "\n",
    "If you were attentive during the course, you should be aware of \n",
    "the canonical way to solve this system. \n",
    "\n",
    "- No, implementing **Householder $QR$** will not be your task :)\n",
    "\n",
    "- We assume that $QR$ decomposition of $A$ **is given**:\n",
    "\n",
    "$$ QR = A = \\begin{bmatrix}a_1 & a_2 & \\ldots & a_n \\end{bmatrix}, \\;\\; a_i \\in \\mathbb{R}^m,$$\n",
    "\n",
    "where $Q \\in \\mathbb{R}^{m \\times m}$ is unitary matrix and $R \\in \\mathbb{R}^{m \\times n}$ is upper triangular.\n",
    "\n",
    "- Let $k$ be an arbitrary column index, $1 \\leq k \\leq n$, and $z \\in \\mathbb{R}^{m}$ be an arbitrary vector.\n",
    "\n",
    "We are interested in matrices:\n",
    "\n",
    "$$ \\tilde{A} = \\begin{bmatrix}a_1 & \\ldots & a_{k-1} & a_{k+1} & \\ldots a_n \\end{bmatrix} \\in \\mathbb{R}^{m \\times (n-1)},$$\n",
    "\n",
    "and:\n",
    "\n",
    "$$ \\hat{A} = \\begin{bmatrix}a_1 & \\ldots & a_{k} & z & a_{k+1} & \\ldots a_n \\end{bmatrix} \\in \\mathbb{R}^{m \\times (n+1)},$$\n",
    "\n",
    "which are obtained by deleting / inserting one column from / to the matrix $A$.\n",
    "\n",
    "For example, if $A$ comes from a least-squares problem, such matrices appear if one wants to examine the significance of the $k^{th}$ parameter in the underlying model (e.g. think in terms of linear regression).\n",
    "\n",
    "- We want to compute decompostions of these updated matrices:\n",
    "\n",
    "$$ \\tilde{A} = \\tilde{Q}\\tilde{R}, \\;\\; \\hat{A} = \\hat{Q}\\hat{R}. $$\n",
    "\n",
    "Performing full orthogonalization process will be redundant. Instead, the known $QR$ factors of $A$ should be **updated** in a proper way.\n",
    "\n",
    "- Different methods for performing $QR$ decomposition were studied during the course. We expect the factors of updated matrices can be recovered with a small number of selective updates, hence the **Givens rotations** seem to be the most appropriate.\n",
    "\n",
    "- Recall the Givens rotation matrix :\n",
    "\n",
    "$$G_{ij}(\\theta) = \\begin{bmatrix} \n",
    "1      & \\ldots & 0      & \\ldots & 0      & \\ldots & 0      \\\\\n",
    "\\vdots & \\ddots & \\vdots &        & \\vdots &        & \\vdots \\\\\n",
    "0      & \\ldots & c      & \\ldots & s      & \\ldots & 0      \\\\\n",
    "\\vdots &        & \\vdots & \\ddots & \\vdots &        & \\vdots \\\\\n",
    "0      & \\ldots & -s     & \\ldots & c      & \\ldots & 0      \\\\\n",
    "\\vdots &        & \\vdots &        & \\vdots & \\ddots & \\vdots \\\\\n",
    "0      & \\ldots & 0      & \\ldots & 0      & \\ldots & 1      \n",
    "\\end{bmatrix}  \\;\\; \\in \\mathbb{R}^{m \\times m}, \\;\\; c = \\cos \\theta, \\;\\; s = \\sin \\theta,$$ \n",
    "\n",
    "which differs from the identity $\\mathrm{I}^{m \\times m}$ by a $2 \\times 2$ sub-matrix:\n",
    "\n",
    "$$\n",
    "{G}(\\theta) = \\begin{bmatrix} c & s \\\\ -s & c \\end{bmatrix} \\in \\mathbb{R}^{2 \\times 2},\n",
    "$$\n",
    "placed on the rows and columns with indices $i$ and $j$. \n",
    "\n",
    "1. (1 pts)\n",
    "Matrix ${G}$ has clear geometric interpretation in 2 dimensions. Let  $a = \\begin{pmatrix} a_1 \\\\ a_2 \\end{pmatrix} \\in \\mathbb{R}^2$ be an arbitrary non-zero vector. According to the template provided below, implement the function to construct matrix $G$, such that:\n",
    "\n",
    "$$ {G}^T \\begin{pmatrix} a_1 \\\\ a_2 \\end{pmatrix} = \\begin{pmatrix} \\alpha \\\\ 0 \\end{pmatrix}.$$\n",
    "\n",
    "What are geometrical meanings of $\\alpha$ and $\\theta$? \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\alpha$ is a norm of a given vector, and $\\theta$ is a rotation angle, which equals to $\\operatorname{arctan} \\frac{\\alpha_2}{\\alpha_1}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 253,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.3282961, 0.       ])"
      ]
     },
     "execution_count": 253,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def givens(a):\n",
    "    '''\n",
    "    Input: \n",
    "        a: np.array of size (2)\n",
    "    Output: \n",
    "        G: np.array of size (2, 2)\n",
    "            Rotation matrix, G^T eliminates the second component of a\n",
    "    '''\n",
    "\n",
    "    theta = np.arctan(a[1] / a[0])\n",
    "    return np.array([\n",
    "        [np.cos(theta), -np.sin(theta)],\n",
    "        [np.sin(theta), np.cos(theta)]\n",
    "    ])\n",
    "    \n",
    "\n",
    "a = np.random.rand(2)\n",
    "givens(a).T.dot(a) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Similarly, matrix $G_{ij}$ can be constructed in order to eliminate the $j^{th}$ component of an arbitrary vector of size $m$. This leads to the well-known **Givens $QR$ algorithm** (see lecture notes!).\n",
    "\n",
    "- Givens rotations typically appear in matrix form:\n",
    "\n",
    "$$ G_{ij}^T X, \\;\\; X^{'}G_{ij},$$\n",
    "\n",
    "where $X$ and $X^{'}$ are some matrices with compatible sizes, e.g. intermediate factors in the **Givens $QR$ algorithm**. \n",
    "\n",
    "How to perform these multiplications efficiently? \n",
    "Obviously, $G_{ij}$ does not need to be stored in explicit form. It affects only two rows / columns, hence only appropriate submatrices should be modified.\n",
    "\n",
    "2. (5 pts) Your second task is to propose an efficient procedure for computing $\\tilde{Q}, \\tilde{R}$ factors of $\\tilde{A}$ by a proper update of $Q, R$ factors of $A$. \n",
    "\n",
    "Hint: consider the following block partition of $R$ (assuming $k^{th}$ column deleted):\n",
    "$$ R = \n",
    "\\begin{bmatrix} \n",
    "R_{11} & v & R_{13} \\\\\n",
    "0 & r_{kk} & \\omega^T \\\\\n",
    "0 & 0 & R^{33}\n",
    "\\end{bmatrix},\n",
    "$$\n",
    "and note, that:\n",
    "$$Q^T\\tilde{A} = \n",
    "\\begin{bmatrix}\n",
    "R_{11} & R_{13} \\\\\n",
    "0 & \\omega^T \\\\\n",
    "0 & R_{33}\n",
    "\\end{bmatrix} = H.$$\n",
    "\n",
    "- (2 pts) What structure has matrix $H$ and how does it help in understanding the proper way to compute updated QR decomposition?\n",
    "\n",
    "- (3 pts) Implement the function according to the template provided below.\n",
    "Use Givens matrices $G_{ij}$ with $j = i+1$ for the convinience.\n",
    "\n",
    "- Only one loop over non-zero subdiagonal elements of $H$ is allowed. You are supposed to perform computations in a proper vectorized form. For example, the *in-place* multiplication $G_{ij}^T X$ with a random matrix $X \\in \\mathbb{R}^{m \\times n}$ can be implemented as follows: ```X[[i,j],:] = G.T.dot(X[[i,j],:])```. \n",
    "\n",
    "- Do not modify elements which are known to be zero.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The matrix $H$ has the structure almost similar to upper triangular: it consists of two upper triangular parts, one of which is shifted one row down. We need to fix that by applying $n - k - 1$ Givens rotations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 284,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rotate(G, i, j, matrix):\n",
    "    matrix[[i, j]] = G.T @ matrix[[i, j]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 461,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.9450461938541466e-14\n"
     ]
    }
   ],
   "source": [
    "def delete_column_QR(A, k):\n",
    "    '''\n",
    "    Input: \n",
    "        A: np.array of size (m, n) \n",
    "            \n",
    "        k: positive integer\n",
    "            Index of deleted column, 0 \\leq k \\leq n - 1\n",
    "        \n",
    "    Output: \n",
    "        Q: np.array of size (m, m)\n",
    "        \n",
    "        R: np.array of size (m, n - 1)\n",
    "\n",
    "    '''\n",
    "    Q, R = np.linalg.qr(A, mode='complete') # factors of $A$ are known\n",
    "    R = np.delete(R, k, axis=1) # delete column\n",
    "    \n",
    "    if k == A.shape[1] - 1:\n",
    "        return Q, R\n",
    "    \n",
    "    Q_T = Q.T\n",
    "    \n",
    "    for idx in range(k, min(R.shape[1], R.shape[0] - 1)):\n",
    "        G = givens(R[[idx, idx + 1], idx])\n",
    "        rotate(G, idx, idx + 1, R)\n",
    "        rotate(G, idx, idx + 1, Q_T)\n",
    "        \n",
    "    return Q_T.T, R\n",
    "\n",
    "# Check yourself\n",
    "m, n = (200, 100)\n",
    "A = np.random.rand(m, n)\n",
    "k = np.random.randint(0, n)\n",
    "A_tilde = np.delete(A, k, axis=1)\n",
    "Q_tilde, R_tilde = delete_column_QR(A, k)\n",
    "print(np.linalg.norm(A_tilde - Q_tilde.dot(R_tilde)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's check if R_tilde is triangular."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 462,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 462,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.allclose(R_tilde, np.triu(R_tilde))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And Q is still orthogonal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 463,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 463,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.allclose(Q_tilde.T @ Q_tilde, np.eye(m))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. (3 pts) When a column is inserted, the factors $\\hat{Q}, \\hat{R}$ of $\\hat{A}$ again can be computed efficiently by a proper update of $Q, R$ factors of $A$.\n",
    "\n",
    "\n",
    "- Proceed similarly to the previous task. Implement the function according to the template provided below. \n",
    "\n",
    "- Choose optimal order of elimination to minimize the number of rotations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 471,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.9978775701740196e-14\n"
     ]
    }
   ],
   "source": [
    "def insert_column_QR(A, k, z):\n",
    "    '''\n",
    "    Input: \n",
    "        A: np.array of size (m, n) \n",
    "            \n",
    "        k: positive integer\n",
    "            Index of inserted column, 0 \\leq k leq n - 1\n",
    "            \n",
    "        z: np.array of size (m)\n",
    "            Inserted column\n",
    "        \n",
    "    Output: \n",
    "        Q: np.array of size (m, m)\n",
    "        \n",
    "        R: np.array of size (m, n + 1)\n",
    "    '''\n",
    "    Q, R = np.linalg.qr(A, mode='complete') # factors of $A$ are known\n",
    "    \n",
    "    Q_T = Q.T\n",
    "    z = Q_T @ z\n",
    "    R = np.insert(R, k, z, axis=1)\n",
    "    \n",
    "    for idx in range(R.shape[0] - 2, k - 1, -1):\n",
    "        G = givens(R[[idx, idx + 1], k])\n",
    "        rotate(G, idx, idx + 1, R)\n",
    "        rotate(G, idx, idx + 1, Q_T) \n",
    "    \n",
    "    return Q_T.T, R\n",
    "\n",
    "\n",
    "# Check yourself\n",
    "m, n = (200, 100)\n",
    "A = np.random.rand(m, n)\n",
    "k = np.random.randint(0, n)\n",
    "z = np.random.rand(m)\n",
    "A_hat = np.insert(A, k, z, axis=1)\n",
    "Q_hat, R_hat = insert_column_QR(A, k, z)\n",
    "print(np.linalg.norm(A_hat - Q_hat.dot(R_hat)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 477,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert np.allclose(R_hat, np.triu(R_hat))\n",
    "assert np.allclose(Q_hat.T @ Q_hat, np.eye(m))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. (3 pts) In the context of least-squares problems, appending rows to a matrix is just as important as inserting columns (e.g. new samples in linear regression).\n",
    "\n",
    "Consider matrix:\n",
    "\n",
    "$$ \\overline{A} = \\begin{bmatrix} \\omega^T \\\\ A \\end{bmatrix} \\in \\mathbb{R}^{(m+1) \\times n},$$\n",
    "\n",
    "which is obtained by appending a row $\\omega^T \\in \\mathbb{R}^{n}$ to the matrix $A$.\n",
    "\n",
    "Similarly to the previous tasks, you need to compute $\\overline{Q}, \\overline{R}$ factors of $\\overline{A}$ by a proper update of $Q,R$ factors of $A$.\n",
    "\n",
    "- Implement the function according to the template provided below. Your code is still expected to be efficient!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 485,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.082691155985234e-14\n"
     ]
    }
   ],
   "source": [
    "def insert_row_QR(A, w):\n",
    "    '''\n",
    "    Input: \n",
    "        A: np.array of size (m, n)\n",
    "\n",
    "        w: np.array of size (n)\n",
    "            Inserted row\n",
    "        \n",
    "    Output:\n",
    "        Q: np.array of size (m + 1, m + 1)\n",
    "        \n",
    "        R: np.array of size (m + 1, n)\n",
    "    '''\n",
    "    Q, R = np.linalg.qr(A, mode='complete')\n",
    "    \n",
    "    m, n = A.shape\n",
    "    Q = np.hstack([np.vstack([np.zeros(m), Q]), np.zeros((m + 1, 1))])\n",
    "    R = np.vstack([R, w])\n",
    "    Q[0, -1] = 1\n",
    "    Q_T = Q.T\n",
    "    \n",
    "    for j in range(0, R.shape[1]):\n",
    "        G = givens(R[[j, -1], j])\n",
    "        rotate(G, j, -1, R)\n",
    "        rotate(G, j, -1, Q_T)\n",
    "    \n",
    "    return Q_T.T, R\n",
    "\n",
    "    \n",
    "# Check yourself\n",
    "m, n = (200, 100)\n",
    "A = np.random.rand(m, n)\n",
    "w = np.random.rand(n)\n",
    "A_overline = np.insert(A, 0, w, axis=0)\n",
    "Q_overline, R_overline = insert_row_QR(A, w)\n",
    "print(np.linalg.norm(A_overline - Q_overline.dot(R_overline)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 486,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert np.allclose(R_overline, np.triu(R_overline))\n",
    "assert np.allclose(Q_overline.T @ Q_overline, np.eye(m + 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem 3 (Word2Vec as Matrix Factorization) 45 pts\n",
    "\n",
    "In this assignment you are supposed to apply SVD to training your own [word embedding model](https://en.wikipedia.org/wiki/Word_embedding) which maps English words to vectors of real numbers.\n",
    "\n",
    "Skip-Gram Negative Sampling (SGNS) word embedding model, commonly known as **word2vec** ([Mikolov et al., 2013](http://papers.nips.cc/paper/5021-distributed-representations-of-words-and-phrases-and-their-compositionality.pdf)), is usually optimized by stochastic gradient descent. However, the optimization of SGNS objective can be viewed as implicit matrix factorization objective as was shown in ([Levy and Goldberg, 2015](http://papers.nips.cc/paper/5477-neural-word-embedding-as-implicit-matrix-factorization.pdf))."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### 1. Notation\n",
    "Assume we have a text corpus given as a sequence of words $\\{w_1,w_2,\\dots,w_n\\}$ where $n$ may be larger than $10^{12}$ and $w_i \\in \\mathcal{V}$ belongs to a vocabulary of words $\\mathcal{V}$. A word $c \\in \\mathcal{V}$ is called *a context* of word $w_i$ if they are found together in the text. More formally, given some measure $L$ of closeness between two words (typical choice is $L=2$), a word $c \\in \\mathcal{V}$ is called a context if $c \\in \\{w_{i-L}, \\dots, w_{i-1}, w_{i+1}, \\dots, w_{i+L} \\}$ Let $\\mathbf{w},\\mathbf{c}\\in\\mathbb{R}^d$ be the *word embeddings* of word $w$ and context $c$, respectively. Assume they are specified by the mapping  $\\Phi:\\mathcal{V}\\rightarrow\\mathbb{R}^d$, so $\\mathbf{w}=\\Phi(w)$. The ultimate goal of SGNS word embedding model is to fit a good mapping $\\Phi$.\n",
    "\n",
    "Let $\\mathcal{D}$ be a multiset of all word-contexts pairs observed in the corpus. In the SGNS model, the probability that word-context pair $(w,c)$ is observed in the corpus is modeled as the following distribution:\n",
    "\n",
    "$$\n",
    "P(\\#(w,c)\\neq 0|w,c) = \\sigma(\\mathbf{w}^\\top \\mathbf{c}) = \\frac{1}{1 + \\exp(-\\mathbf{w}^\\top \\mathbf{c})},\n",
    "$$\n",
    "\n",
    "where $\\#(w,c)$ is the number of times the pair $(w,c)$ appears in $\\mathcal{D}$ and $\\mathbf{w}^\\top\\mathbf{c}$ is the scalar product of vectors $\\mathbf{w}$ and $\\mathbf{c}$. Two important quantities which we will also use further are the number of times the word $w$ and the context $c$ appear in $\\mathcal{D}$, which can be computed as\n",
    "\n",
    "$$\n",
    "\\#(w) = \\sum_{c\\in\\mathcal{V}} \\#(w,c), \\quad \\#(c) = \\sum_{w\\in\\mathcal{V}} \\#(w,c).\n",
    "$$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### 2. Optimization objective"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vanilla word embedding models are trained by maximizing log-likelihood of observed word-context pairs, namely\n",
    "\n",
    "$$\n",
    "\\mathcal{L} = \\sum_{w \\in \\mathcal{V}} \\sum_{c \\in \\mathcal{V}} \\#(w,c) \\log \\sigma(\\mathbf{w}^\\top\\mathbf{c}) \\rightarrow \\max_{\\mathbf{w},\\mathbf{c} \\in \\mathbb{R}^d}.\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Skip-Gram Negative Sampling approach modifies the objective by additionally minimizing the log-likelihood of random word-context pairs, so called *negative samples*. This idea incorporates some useful linguistic information that some number ($k$, usually $k=5$) of word-context pairs *are not* found together in the corpus which usually results in word embeddings of higher quality. The resulting optimization problem is\n",
    "\n",
    "$$\n",
    "\\mathcal{L} = \\sum_{w \\in \\mathcal{V}} \\sum_{c \\in \\mathcal{V}} \\left( \\#(w,c) \\log \\sigma(\\mathbf{w}^\\top\\mathbf{c}) + k \\cdot \\mathbb{E}_{c'\\sim P_\\mathcal{D}} \\log \\sigma (-\\mathbf{w}^\\top\\mathbf{c}) \\right) \\rightarrow \\max_{\\mathbf{w},\\mathbf{c} \\in \\mathbb{R}^d},\n",
    "$$\n",
    "\n",
    "where $P_\\mathcal{D}(c)=\\frac{\\#(c)}{|\\mathcal{D}|}$ is a probability distribution over word contexts from which negative samples are drawn."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Levy and Goldberg, 2015](http://papers.nips.cc/paper/5477-neural-word-embedding-as-implicit-matrix-factorization.pdf) showed that this objective can be equivalently written as\n",
    "\n",
    "$$\n",
    "\\mathcal{L} = \\sum_{w \\in \\mathcal{V}} \\sum_{c \\in \\mathcal{V}} f(w,c) = \\sum_{w \\in \\mathcal{V}} \\sum_{c \\in \\mathcal{V}} \\left( \\#(w,c) \\log \\sigma(\\mathbf{w}^\\top\\mathbf{c}) + \\frac{k\\cdot\\#(w)\\cdot\\#(c)}{|\\mathcal{D}|} \\log \\sigma (-\\mathbf{w}^\\top\\mathbf{c}) \\right) \\rightarrow \\max_{\\mathbf{w},\\mathbf{c} \\in \\mathbb{R}^d},\n",
    "$$\n",
    "\n",
    "A crucial observation is that this loss function depends only on the scalar product $\\mathbf{w}^\\top\\mathbf{c}$ but not on embedding $\\mathbf{w}$ and $\\mathbf{c}$ separately."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### 3. Matrix factorization problem statement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let $|\\mathcal{V}|=m$, $W \\in \\mathbb{R}^{m\\times d}$ and $C \\in \\mathbb{R}^{m\\times d}$ be matrices, where each row $\\mathbf{w}\\in\\mathbb{R}^d$ of matrix $W$ is the word embedding of the corresponding word $w$ and each row $\\mathbf{c}\\in\\mathbb{R}^d$ of matrix $C$ is the context embedding of the corresponding context $c$. SGNS embeds both words and their contexts into a low-dimensional space $\\mathbb{R}^d$, resulting in the word and context matrices $W$ and $C$. The rows of matrix $W$ are typically used in NLP tasks (such as computing word similarities) while $C$ is ignored. It is nonetheless instructive to consider the product $W^\\top C = M$. Viewed this way, SGNS can be described as factorizing an implicit matrix $M$ of dimensions $m \\times m$ into two smaller matrices.\n",
    "\n",
    "Which matrix is being factorized? A matrix entry $M_{wc}$ corresponds to the dot product $\\mathbf{w}^\\top\\mathbf{c}$ . Thus, SGNS is factorizing a matrix in which each row corresponds to a word $w \\in \\mathcal{V}$ , each column corresponds to a context $c \\in \\mathcal{V}$, and each cell contains a quantity $f(w,c)$ reflecting the strength of association between that particular word-context pair. Such word-context association matrices are very common in the NLP and word-similarity literature. That said, the objective of SGNS does not explicitly state what this association metric is. What can we say about the association function $f(w,c)$? In other words, which matrix is SGNS factorizing? Below you will find the answers."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 1 (theoretical) 9 pts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Solve SGNS optimization problem with respect to the $\\mathbf{w}^\\top\\mathbf{c}$ and show that the matrix being factorized is\n",
    "\n",
    "$$\n",
    "M_{wc} = \\mathbf{w}^\\top\\mathbf{c} = \\log \\left( \\frac{\\#(w,c) \\cdot |\\mathcal{D}|}{k\\cdot\\#(w)\\cdot\\#(c)} \\right)\n",
    "$$\n",
    "\n",
    "**Hint:** Denote $x=\\mathbf{w}^\\top\\mathbf{c}$, rewrite SGNG optimization problem in terms of $x$ and solve it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note:** This matrix is called Shifted Pointwise Mutual Information (SPMI) matrix, as its elements can be written as\n",
    "\n",
    "$$\n",
    "\\text{SPMI}(w,c) = M_{wc} = \\mathbf{w}^\\top\\mathbf{c} = \\text{PMI}(w,c) - \\log k\n",
    "$$\n",
    "\n",
    "and $\\text{PMI}(w,c) = \\log \\left( \\frac{\\#(w,c) \\cdot |\\mathcal{D}|}{\\#(w)\\cdot\\#(c)} \\right)$ is the well-known [pointwise mutual information](https://en.wikipedia.org/wiki/Pointwise_mutual_information) of $(w,c)$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "\\mathcal{L} = \\sum_{w \\in \\mathcal{V}} \\sum_{c \\in \\mathcal{V}} \\left( \\#(w,c) \\log \\sigma(\\mathbf{w}^\\top\\mathbf{c}) + \\frac{k\\cdot\\#(w)\\cdot\\#(c)}{|\\mathcal{D}|} \\log \\sigma (-\\mathbf{w}^\\top\\mathbf{c}) \\right)$$\n",
    "\n",
    "$$\n",
    "\\frac{\\partial L}{\\partial (w^Tc)} = \\frac{\\#(w,c)}{\\sigma(\\mathbf{w}^\\top\\mathbf{c})} \\sigma(\\mathbf{w}^\\top\\mathbf{c}) \\Big(1 - \\sigma(\\mathbf{w}^\\top\\mathbf{c})\\Big) - \\frac{k\\cdot\\#(w)\\cdot\\#(c)}{|\\mathcal{D}|\\sigma(-\\mathbf{w}^\\top\\mathbf{c})} \\sigma(-\\mathbf{w}^\\top\\mathbf{c}) \\Big(1 - \\sigma(-\\mathbf{w}^\\top\\mathbf{c})\\Big) = \\#(w,c)\\sigma(-\\mathbf{w}^\\top\\mathbf{c}) - \\frac{k\\cdot\\#(w)\\cdot\\#(c)}{|\\mathcal{D}|}\\sigma(\\mathbf{w}^\\top\\mathbf{c}) = 0\n",
    "$$\n",
    "\n",
    "$$\n",
    "e^{2w^Tc} + \\Big(\\frac{\\#(w,c) \\cdot |\\mathcal{D}|}{k\\cdot\\#(w)\\cdot\\#(c)}-1\\Big)e^{w^Tc} - \\frac{\\#(w,c) \\cdot |\\mathcal{D}|}{k\\cdot\\#(w)\\cdot\\#(c)} = 0\n",
    "$$\n",
    "\n",
    "$$\n",
    "e^{w^Tc} \\in \\{ -1, \\frac{\\#(w,c) \\cdot |\\mathcal{D}|}{k\\cdot\\#(w)\\cdot\\#(c)} \\}\n",
    "$$\n",
    "$$\n",
    "w^Tc = \\log \\frac{\\#(w,c) \\cdot |\\mathcal{D}|}{k\\cdot\\#(w)\\cdot\\#(c)} = M_{wc}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 2 (practical) 36 pts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "from sklearn.metrics.pairwise import cosine_similarity\n",
    "from scipy.sparse.linalg import svds\n",
    "from warnings import filterwarnings\n",
    "\n",
    "filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Download dataset [enwik8](http://mattmahoney.net/dc/enwik8.zip) of compressed Wikipedia articles and preprocess raw data with Perl script **main_.pl**. This script will clean all unnecessary symbols, make all words to lowercase, and produce only sentences with words. If you are Windows user, you can install [linux subsystem in windows](https://www.microsoft.com/en-us/p/ubuntu-1804-lts/9n9tngvndl3q?activetab=pivot:overviewtab) and run all these bash commands from ubuntu console (it was checked on the Windows and it works). Also, you can just download file from this [link](https://nla.skoltech.ru/homeworks/files/enwik8.txt).\n",
    "```\n",
    "wget http://mattmahoney.net/dc/enwik8.zip\n",
    "unzip enwik8.zip\n",
    "mkdir data\n",
    "perl main_.pl enwik8 > data/enwik8.txt\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load enwik 8\n",
    "\n",
    "import re\n",
    "file = open(\"data/enwik8.txt\", \"r\")\n",
    "doclist = [line for line in file]\n",
    "docstr = ''.join(doclist)\n",
    "sentences = re.split(r'[.!?]', docstr)\n",
    "sentences = [sentence.split() for sentence in sentences if len(sentence) > 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['achilles', 'wrath', 'is', 'terrible', 'and', 'he', 'slays', 'many', 'trojan', 'warriors', 'and', 'allies', 'including', 'priam', 's', 'son', 'lycaon', 'whom', 'achilles', 'had', 'previously', 'captured', 'and', 'sold', 'into', 'slavery', 'but', 'who', 'had', 'been', 'returned', 'to', 'troy']\n"
     ]
    }
   ],
   "source": [
    "print (sentences[1249])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Construct the word vocabulary from the obtained sentences which enumerates words which occur more than $r=200$ times in the corpus."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import chain\n",
    "from collections import Counter\n",
    "\n",
    "def create_vocabulary(sentences, r=200):\n",
    "    word2count = Counter(chain.from_iterable(sentences))\n",
    "    words = [word for word, count in word2count.items() if count > r]\n",
    "    vocabulary = {word: id for id, word in enumerate(words)}\n",
    "    return vocabulary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "vocab = create_vocabulary(sentences)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Scan the text corpus with sliding window of size $5$ and step $1$ (which corresponds to $L$=2) and construct co-occurrence word-context matrix $D$ with elements $D_{wc}=\\#(w,c)$. Please, ignore words which occur less than $r=200$ times, but include them into the sliding window. Please, see the graphical illustration of the procedure described."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Sliding window](sliding_window.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import defaultdict\n",
    "from tqdm import tqdm_notebook\n",
    "\n",
    "def create_corpus_matrix(sentences, vocabulary):\n",
    "    corpus_matrix = np.zeros((len(vocabulary), len(vocabulary)))\n",
    "    for sentence in tqdm_notebook(sentences):\n",
    "        for center in range(2, len(sentence) - 3):\n",
    "            i = vocabulary.get(sentence[center])\n",
    "            if i is not None:\n",
    "                for context in sentence[center - 2: center] + sentence[center + 1: center + 3]:\n",
    "                    j = vocabulary.get(context)\n",
    "                    if j is not None:\n",
    "                        corpus_matrix[i][j] += 1\n",
    "    return corpus_matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b729ce926d824ec09e783011cac01775",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=889156), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "D = create_corpus_matrix(sentences, vocab)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. To find good word embeddings, [Levy and Goldberg, 2015](http://papers.nips.cc/paper/5477-neural-word-embedding-as-implicit-matrix-factorization.pdf) proposed to find rank-$d$ SVD of Shifted Positive Pointwise Mutual Information (SPPMI) matrix\n",
    "\n",
    "$$ U \\Sigma V^\\top \\approx \\text{SPPMI}, $$\n",
    "\n",
    "where $\\text{SPPMI}(w, c) = \\max\\left(\\text{SPMI}(w, c), 0 \\right)$ and $\\text{SPMI}(w, c)$ is the element of the matrix $\\text{SPPMI}$ at position $(w, c)$.\n",
    "Then use $W=U\\sqrt{\\Sigma}$ as word embedding matrix. Your task is to reproduce their results. Write function constructs $\\text{SPPMI}$ matrix, computes its SVD and produces word-vectors matrix $W$. Pay attention that $\\text{SPPMI}$ matrix is **sparse**!  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_embeddings(D, k, d=200):\n",
    "    SPMI = np.log(D / np.sum(D, 1).reshape(-1, 1) / np.sum(D, 0).reshape(1, -1)) + np.log(np.sum(D) / k)\n",
    "    SSPMI = np.maximum(SPMI, 0)\n",
    "    U, S, V = svds(SSPMI, d)\n",
    "    embedding_matrix = U * np.sqrt(S)\n",
    "    return embedding_matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "k = 5 # negative sampling parameter\n",
    "W = compute_embeddings(D, k)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5. Write class **WordVectors** using provided template."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's use efficient neighborhood search, not vanilla argsort :)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.neighbors import NearestNeighbors\n",
    "\n",
    "class WordVectors:\n",
    "    def __init__(self, vocabulary, embedding_matrix):\n",
    "        self.vocab = vocabulary\n",
    "        self.W = embedding_matrix\n",
    "        self.inv_vocab = {v: k for k, v in self.vocab.items()}\n",
    "        self.id2word = {id: word for word, id in vocab.items()}\n",
    "        self.tree = NearestNeighbors(1, metric='cosine')\n",
    "        self.tree.fit(self.W)\n",
    "        \n",
    "    def word_vector(self, word):\n",
    "        \"\"\" \n",
    "        Takes word and returns its word vector.\n",
    "        \"\"\"\n",
    "        \n",
    "        id = self.vocab[word]\n",
    "        return self.W[id]\n",
    "    \n",
    "    def nearest_words(self, word, top_n=10):\n",
    "        \"\"\" \n",
    "        Takes word from the vocabulary and returns its top_n\n",
    "        nearest neighbors in terms of cosine similarity.\n",
    "        \"\"\"\n",
    "        \n",
    "        vector = self.word_vector(word)\n",
    "        nearest_ids = np.vstack(self.tree.kneighbors([vector], n_neighbors=top_n + 1)).T[1:]\n",
    "        return [(self.id2word[id], 1 - dist) for dist, id in nearest_ids]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = WordVectors(vocab, W)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('communism', 0.8158544014407968),\n",
       " ('capitalism', 0.7904043022699202),\n",
       " ('anarcho', 0.7868284998105983),\n",
       " ('socialism', 0.7398609062274344),\n",
       " ('liberalism', 0.7028454495931336),\n",
       " ('fascism', 0.5889234756161845),\n",
       " ('capitalist', 0.5867980342585438),\n",
       " ('marxist', 0.5625454231461589),\n",
       " ('anarchist', 0.5554051773719431),\n",
       " ('economics', 0.5249505897177239)]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.nearest_words(\"anarchism\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('ukraine', 0.6485003808049803),\n",
       " ('russia', 0.6424085720438075),\n",
       " ('belarus', 0.5911951487050044),\n",
       " ('serbia', 0.5487932408478218),\n",
       " ('romania', 0.5448021804331599),\n",
       " ('poland', 0.5232549168727507),\n",
       " ('bulgaria', 0.5053249634669279),\n",
       " ('yugoslavia', 0.5046844217046305),\n",
       " ('austria', 0.49736046445836124),\n",
       " ('hungary', 0.4832211324095812)]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.nearest_words(\"ussr\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('hop', 0.8148523330812945),\n",
       " ('hip', 0.8119442023776393),\n",
       " ('funk', 0.7680934651226049),\n",
       " ('rock', 0.7161623857255315),\n",
       " ('music', 0.7000793564461767),\n",
       " ('punk', 0.6848853223369142),\n",
       " ('jazz', 0.6361686135016744),\n",
       " ('pop', 0.6329715937724899),\n",
       " ('scene', 0.5931701102115849),\n",
       " ('band', 0.5866582440959354)]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.nearest_words(\"rap\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6. Calculate top 10 nearest neighbours with the corresponding cosine similarities for the words {matrix, multiplication, algorithm} and print them below"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('multiplication', 0.5537733090717789),\n",
       " ('polynomial', 0.43694035654692764),\n",
       " ('algebraic', 0.4348589574639252),\n",
       " ('algebra', 0.43005621696576957),\n",
       " ('graph', 0.42333008648243453),\n",
       " ('theorem', 0.41236494396914236),\n",
       " ('equations', 0.40484473864225556),\n",
       " ('equation', 0.40156968549959027),\n",
       " ('euclidean', 0.3849117398574883),\n",
       " ('geometry', 0.366967259230242)]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.nearest_words('matrix')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('polynomial', 0.7520833443152155),\n",
       " ('inverse', 0.6489215830142931),\n",
       " ('linear', 0.6436395468075174),\n",
       " ('equations', 0.6317427142497383),\n",
       " ('algebra', 0.6110836447346795),\n",
       " ('algebraic', 0.6052133314624089),\n",
       " ('functions', 0.5961930395329607),\n",
       " ('equation', 0.590080283050799),\n",
       " ('matrix', 0.5537733090717789),\n",
       " ('differential', 0.541316121958752)]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.nearest_words('multiplication')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('algorithms', 0.7440126107822691),\n",
       " ('polynomial', 0.6130419903668081),\n",
       " ('methods', 0.5549679221412371),\n",
       " ('problem', 0.5415562108567411),\n",
       " ('integer', 0.5402057344128814),\n",
       " ('functions', 0.5180892311361944),\n",
       " ('multiplication', 0.5088035057175543),\n",
       " ('method', 0.47628020907322344),\n",
       " ('efficient', 0.46818384910389876),\n",
       " ('simple', 0.45722671868566567)]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.nearest_words('algorithm')    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Problem 4 (eigenvalues)  45 pts\n",
    "\n",
    "### 1. Theoretical tasks (10 pts)\n",
    "\n",
    "* (5 pts) Prove that normal matrix is Hermitian iff its eigenvalues are real. Prove that normal matrix is unitary iff its eigenvalues satisfy $|\\lambda| = 1$. \n",
    "\n",
    "* (5 pts) The following problem illustrates instability of the Jordan form. Find theoretically the eigenvalues of the perturbed Jordan block:\n",
    "\n",
    "$$\n",
    "    J(\\varepsilon) = \n",
    "    \\begin{bmatrix} \n",
    "     \\lambda & 1 & & & 0 \\\\ \n",
    "     & \\lambda & 1 & & \\\\ \n",
    "     &  & \\ddots & \\ddots & \\\\ \n",
    "     & & & \\lambda & 1 \\\\ \n",
    "     \\varepsilon & & & & \\lambda  \\\\ \n",
    "    \\end{bmatrix}_{n\\times n}\n",
    "$$\n",
    "\n",
    "Comment how eigenvalues of $J(0)$ are perturbed for large $n$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Normal matrix: $AA^* = A^*A$\n",
    "  \n",
    "  Hermitian matrix: $A = A^*$\n",
    "  \n",
    "  Normal matrix & eigenvalues are real $\\Rightarrow$ Hermitian:\n",
    "  \n",
    "  If $A$ is normal, then it is diagonalizable by some unitary $Q$:\n",
    "  \n",
    "  $$A = Q\\Lambda Q^*$$\n",
    "  $$A^* = Q\\Lambda^* Q^*$$\n",
    "  \n",
    "  *Proof can be found [here](http://fourier.eng.hmc.edu/e161/lectures/algebra/node8.html), but it needs to be fixed: $C = \\frac{1}{2\\textbf{i}} (A - A^*)$ instead of $C = -\\frac{1}{2} (A - A^*)$*.\n",
    "  \n",
    "  Here matrix $\\Lambda$ consists of the eigenvalues, and taking into accout that all of them are real:\n",
    "  \n",
    "  $$\\Lambda = \\Lambda^*$$\n",
    "  \n",
    "  Thus,\n",
    "  \n",
    "  $$A = Q\\Lambda Q^* = Q\\Lambda^* Q^* = A^*$$\n",
    "  \n",
    "  Normal matrix & Hermitian $\\Rightarrow$ eigenvalues are real:\n",
    "  \n",
    "  $$Ax = \\lambda x$$\n",
    "  $$x^*Ax = \\lambda \\|x\\|$$\n",
    "  $$x^*A^*x = \\lambda^* \\|x\\|$$\n",
    "  $$A = A^* \\Rightarrow \\lambda \\|x\\| = x^*Ax = x^*A^*x = \\lambda^* \\|x\\|$$\n",
    "  $$\\lambda^* = \\lambda$$\n",
    "  \n",
    "* In order to find eigenvalues analytically we need to compute characteristical polymomial.\n",
    "  $$\\operatorname{det} (J(\\epsilon) - \\mu I) = (\\lambda - \\mu)^n + (-1)^{n+1} \\epsilon = 0$$\n",
    "  $$\\mu = \\lambda - \\epsilon^{\\frac{1}{n}} $$\n",
    "  Let's consider some small perturbation practically..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 282,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Relative error is: 0.04 for n = 10\n",
      "Relative error is: 0.72 for n = 100\n",
      "Relative error is: 0.97 for n = 1000\n",
      "Relative error is: 0.99 for n = 5000\n"
     ]
    }
   ],
   "source": [
    "eps = 10e-15\n",
    "lmbda = 1\n",
    "\n",
    "for dim in [10, 100, 1000, 5000]:\n",
    "    print(f'Relative error is: {np.power(eps, 1 / dim) / lmbda:.2} for n = {dim}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. PageRank\n",
    "\n",
    "\n",
    "#### Damping factor importance\n",
    "\n",
    "* (5 pts) Write the function ```pagerank_matrix(G)``` that takes an adjacency matrix $G$ (in both sparse and dense formats) as an input and outputs the corresponding PageRank matrix $A$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy.sparse as scp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# INPUT:  G - np.ndarray or sparse matrix\n",
    "# OUTPUT: A - np.ndarray (of size G.shape) or sparse matrix\n",
    "def pagerank_matrix(G):\n",
    "    if scp.issparse(G):\n",
    "        A = scp.csc_matrix(G.T, dtype=np.float)\n",
    "        col_sums = np.array(A.sum(0)).ravel()\n",
    "        zeros = col_sums == 0\n",
    "        col_sums[zeros] = 1\n",
    "        A = A @ scp.diags([1 / col_sums], [0])\n",
    "        A[:, np.where(zeros)] = 1 / A.shape[0]\n",
    "    else:\n",
    "        A = G.T\n",
    "        A = A / A.sum(0)\n",
    "        A[np.isnan(A)] = 1 / A.shape[0]\n",
    "    return A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* (3 pts) Find PageRank matrix $A$ that corresponds to the following graph: <img src=\"graph.png\" width='250'>\n",
    "What is its largest eigenvalue? What multiplicity does it have?\n",
    "\n",
    "\n",
    "* (5 pts) Implement the power method for a given matrix $A$, an initial guess $x_0$ and a number of iterations ```num_iter```. It should be organized as a function ```power_method(A, x0, num_iter)``` that outputs approximation to eigenvector $x$, eigenvalue $\\lambda$ and history of residuals $\\{\\|Ax_k - \\lambda_k x_k\\|_2\\}$. Make sure that the method converges to the correct solution on a matrix $\\begin{bmatrix} 2 & -1 \\\\ -1 & 2 \\end{bmatrix}$ which is known to have the largest eigenvalue equal to $3$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "G = np.array([\n",
    "    [0, 1, 0, 0, 0],\n",
    "    [0, 0, 1, 0, 0],\n",
    "    [1, 1, 0, 0, 0],\n",
    "    [0, 0, 0, 0, 1],\n",
    "    [0, 0, 0, 1, 0]\n",
    "])\n",
    "A = pagerank_matrix(G)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 340,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.5+0.5j, -0.5-0.5j,  1. +0.j ,  1. +0.j , -1. +0.j ])"
      ]
     },
     "execution_count": 340,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.eigvals(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 341,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.5, -0.5,  1. ,  1. , -1. ])"
      ]
     },
     "execution_count": 341,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.eigvals(A).real"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The largest eigenvalue is 1, it's multiplicity is 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# INPUT:  A - np.ndarray (2D), x0 - np.ndarray (1D), num_iter - integer (positive)\n",
    "# OUTPUT: x - np.ndarray (of size x0), l - float, res - np.ndarray (of size num_iter + 1 [include initial guess])\n",
    "def power_method(A, x0, num_iter): # 5 pts\n",
    "    res = []\n",
    "    for _ in range(num_iter):\n",
    "        x = A @ x0\n",
    "        l = np.linalg.norm(x)\n",
    "        res.append(np.linalg.norm(x - l * x0))\n",
    "        x0 = x / l\n",
    "    return x0, l, res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 343,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lambda: 3.0, residual: 0.0\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[2, -1], [-1, 2]])\n",
    "n_iter = 50\n",
    "x, l, res = power_method(A, np.random.randn(2), n_iter)\n",
    "print(f'lambda: {l}, residual: {res[-1]}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* (2 pts) Run the power method for the graph presented above and plot residuals $\\|Ax_k - \\lambda_k x_k\\|_2$ as a function of $k$ for ```num_iter=100``` and random initial guess ```x0```.  Explain the absence of convergence. \n",
    "\n",
    "\n",
    "* (2 pts) Consider the same graph, but with additional self loop at node 4 (self loop is an edge that connects a vertex with itself). Plot residuals as in the previous task and discuss the convergence. Now, run the power method with ```num_iter=100``` for 10 different initial guesses and print/plot the resulting approximated eigenvectors. Why do they depend on the initial guess?\n",
    "\n",
    "\n",
    "In order to avoid this problem Larry Page and Sergey Brin [proposed](http://ilpubs.stanford.edu:8090/422/1/1999-66.pdf) to use the following regularization technique:\n",
    "\n",
    "$$\n",
    "A_d = dA + \\frac{1-d}{N} \\begin{pmatrix} 1 & \\dots & 1 \\\\ \\vdots & & \\vdots \\\\ 1 & \\dots & 1 \\end{pmatrix},\n",
    "$$\n",
    "\n",
    "where $d$ is a small parameter in $[0,1]$ (typically $d=0.85$), which is called **damping factor**, $A$ is of size $N\\times N$. Now $A_d$ is the matrix with multiplicity of the largest eigenvalue equal to 1. \n",
    "Recall that computing the eigenvector of the PageRank matrix, which corresponds to the largest eigenvalue, has the following interpretation. Consider a person who stays in a random node of a graph (i.e. opens a random web page); at each step s/he follows one of the outcoming edges uniformly at random (i.e. opens one of the links). So the person randomly walks through the graph and the eigenvector we are looking for is exactly his/her stationary distribution â€” for each node it tells you the probability of visiting this particular node. Therefore, if the person has started from a part of the graph which is not connected with the other part, he will never get there.  In the regularized model, the person at each step follows one of the outcoming links with probability $d$ OR teleports to a random node from the whole graph with probability $(1-d)$.\n",
    "\n",
    "* (2 pts) Now, run the power method with $A_d$ and plot residuals $\\|A_d x_k - \\lambda_k x_k\\|_2$ as a function of $k$ for $d=0.97$, ```num_iter=100``` and a random initial guess ```x0```.\n",
    "\n",
    "* (5 pts) Find the second largest in the absolute value eigenvalue of the obtained matrix $A_d$. How and why is it connected to the damping factor $d$? What is the convergence rate of the PageRank algorithm when using damping factor?\n",
    "\n",
    "Usually, graphs that arise in various areas are sparse (social, web, road networks, etc.) and, thus, computation of a matrix-vector product for corresponding PageRank matrix $A$ is much cheaper than $\\mathcal{O}(N^2)$. However, if $A_d$ is calculated directly, it becomes dense and, therefore, $\\mathcal{O}(N^2)$ cost grows prohibitively large for  big $N$.\n",
    "\n",
    "\n",
    "* (2 pts) Implement fast matrix-vector product for $A_d$ as a function ```pagerank_matvec(A, d, x)```, which takes a PageRank matrix $A$ (in sparse format, e.g., ```csr_matrix```), damping factor $d$ and a vector $x$ as an input and returns $A_dx$ as an output. \n",
    "\n",
    "* (1 pts) Generate a random adjacency matrix of size $10000 \\times 10000$ with only 100 non-zero elements and compare ```pagerank_matvec``` performance with direct evaluation of $A_dx$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 347,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "G = np.array([\n",
    "    [0, 1, 0, 0, 0],\n",
    "    [0, 0, 1, 0, 0],\n",
    "    [1, 1, 0, 0, 0],\n",
    "    [0, 0, 0, 0, 1],\n",
    "    [0, 0, 0, 1, 0]\n",
    "])\n",
    "A = pagerank_matrix(G)\n",
    "\n",
    "plt.figure(figsize=(10, 7))\n",
    "for n in range(5):\n",
    "    plt.semilogy(range(100), power_method(A, np.random.randn(5), 100)[2], label=f'guess_{n}')\n",
    "plt.legend()\n",
    "plt.xlabel('n_iter')\n",
    "plt.ylabel('residual');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 348,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.5, -0.5,  1. ,  1. , -1. ])"
      ]
     },
     "execution_count": 348,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.eigvals(A).real"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 349,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.70710678, 0.70710678, 1.        , 1.        , 1.        ])"
      ]
     },
     "execution_count": 349,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sqrt((np.linalg.eigvals(A) * np.linalg.eigvals(A).conjugate()).real)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The algorithm stucks with different residuals initialized with randomly generated vectors, and this residuals never turn to zero, which means absence of convergence. It happens because power method requires $|\\lambda_1| > |\\lambda_2| \\geq |\\lambda_3| \\geq \\dots \\geq |\\lambda_n|$, and it guarantees convergence with ratio $\\frac{|\\lambda_2|}{|\\lambda_1|}$, but we have two equal maximal (by norm) eigenvalues with different signs from different eigenspaces, therefore the convergence is not guaranteed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 350,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAm4AAAGqCAYAAACyOcgsAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdeXhN59rH8e9KsjPLPJBIRMxzZEBRRSsxU/NQ1NwetHXKKXU6quLUaaulWoqidDBPbQ1tUxVFIomIICEJEpFRxp2dZO+93j/0eKsShCC4P9eVq8221rPuJ+rqz7PWem5FVVWEEEIIIUT1Z/KgCxBCCCGEELdHgpsQQgghxENCgpsQQgghxENCgpsQQgghxENCgpsQQgghxEPC7EEXcD+4uLioPj4+D7oMIYQQQohbOnbsWJaqqq7l/dpjEdx8fHyIiIh40GUIIYQQQtySoijnK/o1uVUqhBBCCPGQkOAmhBBCCPGQkOAmhBBCCPGQeCyecRNCCCHE/VFWVkZKSgo6ne5Bl1LtWVpaUrt2bTQazW2fI8FNCCGEEFUmJSWFGjVq4OPjg6IoD7qcaktVVbKzs0lJSaFu3bq3fZ7cKhVCCCFEldHpdDg7O0touwVFUXB2dq70yqQENyGEEEJUKQltt+dOfk4S3IQQQgghHhIS3IQQQgghHhIS3IQQQgghqlhOTg7dunWjQYMGdOvWjStXrlTJuBLchBBCCCGq2IIFC3j66adJSEjg6aefZsGCBVUyrmwHIoQQQoh74p2dJ4m7lF+lYzb1sOOtPs1ueszcuXNZv349Xl5euLi4EBAQwK5du1i0aBGBgYFkZWURGBhIcnIyBoOBWbNmERoaSklJCVOmTGHy5MmkpaUxdOhQ8vPz0ev1LFu2jPbt2zN+/HgiIiJQFIVx48Yxffr0cmvYvn07oaGhAIwZM4bOnTuzcOHCu56/BDchhBBCPDIiIiLYvHkzUVFR6PV6/P39CQgIqPD4lStXYm9vT3h4OCUlJXTo0IHg4GC2bNlCSEgIc+bMwWAwoNVqiY6OJjU1ldjYWAByc3MrHDc9PZ1atWoBUKtWLTIyMqpkfhLchBBCCHFP3Gpl7F44ePAg/fr1w8rKCoA+ffrc9Pi9e/cSExPDpk2bAMjLyyMhIYGgoCDGjRtHWVkZ/fv3x8/PD19fXxITE5k2bRq9evUiODj4ns/n7+QZtypiyM3FkJf3oMsQQgghHmuqqpb7uZmZGUajEeC6TW9VVeXTTz8lOjqa6OhokpKSCA4OplOnThw4cABPT09GjRrF2rVrcXR05Pjx43Tu3JmlS5cyYcKECutwd3cnLS0NgLS0NNzc3KpkfhLcqoA+J4f4JzuRu3Hjgy5FCCGEeKx17NiRnTt3otPpKCwsZPfu3QD4+Phw7NgxgGurawAhISEsW7aMsrIyAOLj4ykqKuL8+fO4ubkxceJExo8fT2RkJFlZWRiNRgYOHMjcuXOJjIyssI6+ffuyZs0aANasWUO/fv2qZH5yq7QKmDk5YfDxJefHPTjfJH0LIYQQ4t4KCgqib9++tGrVijp16hAYGIi9vT0zZsxgyJAhrFu3jq5du147fsKECSQnJ+Pv74+qqri6urJt2zZCQ0P54IMP0Gg02NrasnbtWlJTUxk7duy1lbv58+dXWMesWbMYMmQIK1euxNvbm41VtLijVLSk+CgJDAxUIyIi7tn4qZlFrHv1G7rGfU/rHV+h8fC4Z9cSQgghqrNTp07RpEmTB1pDYWEhtra2aLVaOnXqxPLly/H393+gNVWkvJ+XoijHVFUNLO94uVVaBazNDVjZeXK64TDObd71oMsRQgghHmuTJk3Cz88Pf39/Bg4cWG1D252QW6VVwMLajEP1ttBJP5wTv/5C42kPuiIhhBDi8bVhw4b7dq0pU6YQFhZ23Wcvv/wyY8eOvSfXk+BWBaw11tQPdKPs9BmynZ7g119i6dK1+YMuSwghhBD32NKlS+/r9eRWaRXpW78vv/t8j2piRtS3segNxgddkhBCCCEeMRLcqkhQzSDyG5jhkvULFiZufL39zIMuSQghhBCPGAluVcREMaG3b2/iHfdgpc3g8v4UcgtKHnRZQgghhHiESHCrQn18+/BHIz2NEr6lhtGU1V8ef9AlCSGEEOIRIsGtCvk6+FKjSXNUkyRqaBMwOVPAqTPZD7osIYQQQtxnGzdupFmzZpiYmFCVe8lKcKtifer35WCDMlrEfIUBlZ8WH+fgD4kY5GUFIYQQ4rHRvHlztmzZQqdOnap0XNkOpIr1qNuDCY0X0u9wLn4NM9ib7MbxHcnEh6Xx9PDG1GnufMdj6w1GygwqVuamVVixEEIIcY/8OAsun6jaMWu2gB4LbnrI3LlzWb9+PV5eXri4uBAQEMCuXbtYtGgRgYGBZGVlERgYSHJyMgaDgVmzZhEaGkpJSQlTpkxh8uTJpKWlMXToUPLz89Hr9Sxbtoz27dszfvx4IiIiUBSFcePGMX369HJruFfdIx7K4KYoig3wGVAKhKqquv6BFmTQw743ofVzOLo3xTOoEzlbf6V+/AE83/4Pby6LoEVmMbuWHMe7mRMdBzfAsabNTYc8dv4Ke05eJjW3mLTcYtLydKTn6zA1UXi+vQ9TuzbA3kpznyYohBBCPBwiIiLYvHkzUVFR6PV6/P39CQgIqPD4lStXYm9vT3h4OCUlJXTo0IHg4GC2bNlCSEgIc+bMwWAwoNVqiY6OJjU1ldjYWAByc3Pv17SuqTbBTVGUVUBvIENV1eZ/+bw7sBgwBb5UVXUBMADYpKrqTkVRvgMebHAryoTYzRC3Dcbvo2/9fhxq+DO9wsJoZGvCsn915MW1EejP5NPlzBXS5kcQPL4ZPi1dbhjqVFo+i/ac4efTGZibmeBhb0kteyva13PBw8GSS7k6vjyYxObIVF4NbsjQQC/MTOWOtxBCiGroFitj98LBgwfp168fVlZWAPTp0+emx+/du5eYmBg2bdoEQF5eHgkJCQQFBTFu3DjKysro378/fn5++Pr6kpiYyLRp0+jVqxfBwcH3fD5/V22CG/AVsARY+78PFEUxBZYC3YAUIFxRlB1AbeB/a6+G+1tmOexqwXObYFUPWD+ITqO3s665Lb3DC8j97jschg5j3cR2vLk9ls+PXGR4iRW7PovBpo0zT/SoSwP3GlzM0fLhvnh2xlyihoUZM0MaMbaDD9bmN/4Wje3gw7s745izNZZ1f5znjd5N6VD/xhAohBBCPG5UVS33czMzM4zGq8+b63S6647/9NNPCQkJueGcAwcOsHv3bkaNGsXMmTMZPXo0x48fZ8+ePSxdupTvv/+eVatW3ZuJVKDaLNWoqnoAyPnbx22As6qqJqqqWgp8C/Tjaoir/ecx1WMONVvAsK8hKwHzjWNp0KEnl5wVMj5YRHxQEBf79WXa0Q0sdkgi1aeURAsj2qPZfDz/MH5v7eHpD39jX1w6Lz5Vj9//1ZUpXeqXG9oAmnva893kdnw20p/CEj0jvzzCh/viK/yPVQghhHhcdOzYkZ07d6LT6SgsLGT37t0A+Pj4cOzYMYBrq2sAISEhLFu2jLKyMgDi4+MpKiri/PnzuLm5MXHiRMaPH09kZCRZWVkYjUYGDhzI3LlziYyMvO/zq04rbuXxBC7+5fsUoC3wCbBEUZRewM7yTlQUZRIwCcDb2/sel/kn387Q/zPYMpE+VlZMHGPCezWeo3VODXQnYikKC8MjK4t/entRZ+t2ft55HkIv0UivoaStE+OerodbDcvbupSiKPRsUYuujd14Y1ssn/ycwKXcYuYPaIFGbp0KIYR4TAUFBdG3b19atWpFnTp1CAwMxN7enhkzZjBkyBDWrVtH165drx0/YcIEkpOT8ff3R1VVXF1d2bZtG6GhoXzwwQdoNBpsbW1Zu3YtqampjB079trK3fz58yusY+vWrUybNo3MzEx69eqFn58fe/bsuev5KdVplUZRFB9g1/+ecVMUZTAQoqrqhD+/HwW0UVV1WmXGDQwMVKtyD5VbCluMuu9NBjRoRpGFDVsC38I2NRI1OYyiP45ycb8lLgEKrk+5E69tzy/xnTHTKDR+sg7NOnrc8sWFv1NVlY/3J7D45wSebODCsucCsLWo7plcCCHEo+jUqVP37I3K21VYWIitrS1arZZOnTqxfPly/P39H2hNFSnv56UoyjFVVQPLO766/989BfD6y/e1gUsPqJbb1/4llPxLvB29itG13Fm0axRvZ+WgONXDtlsv7HLiyT6ein1bWxpa/oZjrYMcy36GEz8rHN9/EY8GDjTt6EE9f1fMNLfe+kNRFKZ3a4iHgyWvb41lyOd/8NXYINzsbm/1TgghhHiUTJo0ibi4OHQ6HWPGjKm2oe1OVPfgFg40UBSlLpAKDANGPNiSboOiQMj7tLJy4vmMMFYpSTwdspgnG/QFwK1dBoU9e3L5RC28lu/A1ain+3fPoT31JafrL+HkWSv2r47j4Pcamj3pQYvOtbFxsLjlZYcGeeNmZ8mU9ZE8+9kh/tW9ESHNamJ5G+FPCCGEeFRs2LDhvl1rypQphIWFXffZyy+/zNixY+/J9arNrVJFUb4BOgMuQDrwlqqqKxVF6Ql8zNXtQFapqjqvsmPf91ulf1FqKGXorqHkl+Szpd8W7C3sAchZu5b09+fj+cli7IKDoawY1g+G84dQh6wjRXmCE7+mkBSThYmJQv1AN/ye9sbVu8Ytr3kiJY8pGyK5kKPFztKM/q09GRLoRXNP+3s9XSGEEI+56nCr9GFS2Vul1Sa43UsPMrgBnMw+ycjdI+nl24t5Ha/mTlWvJ2nQYAy5udTbvQsTGxsoKYC1/a7uMj1yI/h2Ji9TS8wvKZw6lEZZiQG3OjVwqmWDrZMlto4W2DhY4OBmjYO79XXXNBpVDp3L5vuIi/x08jKleiONa9bA3c6SohI9hX9+FZcaaF/fhTk9m1DTXm6tCiGEuDsS3CpHgls5HnRwA1gStYQvYr7gky6f0MW7CwDaqCjODx+B0/hxuM+cefVAbQ581QuunIfR28CrDQAlxXpOhV3iXGQmhVd0FOWW8NffurqtXOg4uAF2LlY3XDtPW8aO46nsOH6JUr0RGwszbP/8UhSFXTGX0JiaML1bQ8Y8UUc29BVCCHHHJLhVjgS3clSH4FZmKGP47uFkFWexqe8misuKuVBwAXXBUhx/ieaXd3vh3LQ1vg6++JrWwPXbkShFOTD8G/DpcMN4RoORorxSCq+UkHomh2N7LqAaVFoHe+PfvQ6aSvQzvZCt5c0dsYSeyaRpLTvee7Y5/t6OVTl9IYQQjwkJbpUjwa0c1SG4AZzJOcOw3cPQG/XXPrPVqixebqTEHMIaQ0xdhdNeChaWNrQp1jH/8mWsB62Cxr1uOnbhFR2HtpwjITwdWycLOgxsQD1/VxRFua3aVFXlp9jLvL3zJBkFJUztUp9Xgxvd1XyFEEI8fiS4VY4Et3JUl+AGsDd5L6dyTuFdwxtvO2+8a3hjFZ1A9hfL0R47Bno9RnMzMhq4EOaYgZuZCc8W5KDxH4bSsAtm7m5YBwVVGMguJeRy4Lt4slMK6TSsIS061y73uIoUluh5c3ssWyJTWTCgBcPa3KfNi4UQQjwSJLhdNXPmTHbu3Im5uTn16tVj9erVODg43HCcBLdyVKfgdjNGrRZteDhFhw5RGBZG6dlz5R5n27kzNd95B427W/njGIzsWhrD5cQ8RrzVFlvHyr10oDcYGftVOIcTs/l6fFva+jpXei5CCCEeTxLcrtq7dy9du3bFzMyM1157DYCFCxfecJwEt3I8LMHt71S9npURy1gd+QUjcWX82RgKNV3I3HMOxdycmnNex65v33JX3/Iyi/n23SN4NXWi54stK33tvOIynl0aRm5xGdundMDLyfrWJwkhhHjs/TWILDy6kNM5p6t0/MZOjXmtzWs3PWbu3LmsX78eLy8vXFxcCAgIYNeuXSxatIjAwECysrIIDAwkOTkZg8HArFmzCA0NpaSkhClTpjB58mTS0tIYOnQo+fn56PV6li1bRvv27Rk/fjwREREoisK4ceOYPn36LWveunUrmzZtYv369Tf8WmWDm7w+WI0pZmaMbzuVHv7DWGaTxXcdnsbZah++QzRYeLlz6bVZpEyZij4z84Zz7V2tCOpTl6TjWZyLyqj0te2tNHw5JhC9wciENREUluhvfZIQQgjxgEVERLB582aioqLYsmULt1q4WblyJfb29oSHhxMeHs6KFStISkpiw4YNhISEEB0dzfHjx/Hz8yM6OprU1FRiY2M5ceLEbW+yu2rVKnr06FEV06v2nRMee4qiMLvNbLKLs/ngwn5cu71GjyPrqdPsN3LqdiFz30ESe/fB68svsWrR/Lpz/Z72IiE8nQPfxlO7sRMWVpX77fZ1tWXpSH+eXx3OK99G8cWoQExNbu9lByGEEOJWK2P3wsGDB+nXrx9WVle3x+rTp89Nj9+7dy8xMTFs2rQJgLy8PBISEggKCmLcuHGUlZXRv39//Pz88PX1JTExkWnTptGrVy+Cg4NvWc+8efMwMzNj5MiRdz85ZMXtoWBqYsqCTgsIcA/g9cSNRAz+HKX9FJxr/Ebd3lpMzBUuThxP6aHNcO5XSNgP537BRNXTeWRjivNLOby1/OflbuXJBq680asJ+09l8P4PpzAaH/1b60IIIR5eFT0CZmZmhtFoBECn0113/Keffkp0dDTR0dEkJSURHBxMp06dOHDgAJ6enowaNYq1a9fi6OjI8ePH6dy5M0uXLmXChAk3rWXNmjXs2rWL9evX3/YuD7ciwe0hYWFqweIui6ltW5vpYa9zscOLMPFXLLw98Ao6A9pcLr48C/2KAbB+IKx7FlZ0xd3yAi27eBF7IJW0s7l3dO0x7X0Y80QdVh5M4sX1x+S2qRBCiGqrY8eO7Ny5E51OR2FhIbt37wbAx8eHY8eOAVxbXQMICQlh2bJllJWVARAfH09RURHnz5/Hzc2NiRMnMn78eCIjI8nKysJoNDJw4EDmzp1LZGRkhXX89NNPLFy4kB07dmBtXXXPiUtwe4jYW9iz5OklGFUj036eRoFLPZj4CxYv7aT2+/+irMSKi6fbYxy5GwauhMLLsKILbVx/wNbJgl/Xn8GgN1b6uoqi8HbfZrzRuyn7T2XQf2kYiZmF92CGQgghxN0JCgqib9++tGrVigEDBhAYGIi9vT0zZsy49oJBVlbWteMnTJhA06ZN8ff3p3nz5kyePBm9Xk9oaCh+fn60bt2azZs38/LLL5Oamkrnzp3x8/Pj+eefZ/78+RXWMXXqVAoKCujWrRt+fn688MILVTI/eav0IXQ07SiT902mrUdblnRdgpnJ1WfXCvbvJ+Wll7F96ilqf/oJSkku7HoFTu0kucYIdicMxtJGg6u3La7eNXD1tsPV25YaTpaY3Gabq0Pnspi6IYoyvZGPh/nxdBP3ezlVIYQQD5nqsB1IYWEhtra2aLVaOnXqxPLly/H393+gNVVEtgMpx6MW3AC+P/M9cw/P5bkmz1338GfOhg2kvzsXhyFDqPnO2ygAMd/DDzM5W9iaix4vkZFbg5xLRRgN//97b25pioWNBgtrMyxtNPi0cKFl19rl3pNPuaLlha+PcfJSPgP9a6MAOUWlZBeVklNUipmJwj+61GdAa09M5GUGIYR4rFSH4DZixAji4uLQ6XSMGTOG2bNnP9B6bqaywU3eKn1IDWk0hKS8JL4+9TW+Dr4MbjgYAKcRI9CnXSZ7xQpMrK1xe+1fKK2Ggk8H6q8fTP2iF2D6EQwaB3LSisi8UEBRXgm6ojJKivTotGUU5pRwcGMCWSkFdB7ZGFOz61fjajtas+mF9ryxLZadMZdwsDLH0cYcZxtzvJ2sSc4uYsbG46w7fJ63+jSVvqdCCCHuqw0bNty3a02ZMoWwsLDrPnv55Zdve6uQypIVt4eY3qhn6i9T+ePSH9R3qE9jp8Y0dGxIY8dG1Fy+G+23m3AYPJiab7+FYmoKaTGwogs0GwADV1Q4rqqqhO9OJnxXEp4NHeg+uQWWNprbrstoVNkWncqCH0+TUVDCgNaevNajMe52levgIIQQ4uFTHVbcHiZyq7Qcj2pwAygsLWRN3Bpis2I5k3OGzOI/N+NVVcYdsqT7gSJS2tUl91+jqe/SiJYnf8T0t4UwbMMtG9efOXKZX9adws7Zit5TW2LvWrm3YgpL9Hz261m+/D0JjanChontaOV1Y582IYQQjw4JbpUjwa0cj3Jw+7vs4mzOXDlDfE48Z3PP4r7lEM/8kEZEfYWPnjWhjVd7Pkw8iXVBBkw5AtZONx3vUkIuP35+AoCeL7agVv3KB6/z2UWMWHEEgB9eehJ769tfvRNCCPFwkeBWORLcyvE4BbfyZK9fT8bc98hv4cM3Xik00dagW9JlFIMzZTpLrFq0wHX6K1g2bFju+bkZWnYvjUGbV8LQf7fBzsWq0jVEX8xl8OeHeKqhKytGB1bZRoRCCCGqFwlulSO9SsUNnEeOxGPhAuziLjL5Bz3tD1whNd+KUkMOts3roI2IIKn/s1x6fQ5laWk3nO/gZk2faa1AUdjz5UkMhsrvBefn5cCcnlc7MKz4PbEqpiWEEEI8diS4PSbs+/Wj/s/7qf/zftSfN/D6y05MGmPDlUZHqbf9O5zGjCF/507Ode9BxqJFGPLzrzvfzsWKLs81JiM5nyPb7yx4jWnvQ88WNVn40xkiknOqYlpCCCFEtfTGG2/QsmVL/Pz8CA4O5tKlS1UyrgS3x4imZk00np60rNWatT3WYmXtwlgHDZEbe+DuX0i9DZ9h1z2E7JWrOD96DMaSkuvOrx/gRrMnPYjae4ELcdmVvr6iKCwY2BIvRyumbogiu7Dk1icJIYQQD6GZM2cSExNDdHQ0vXv35t13362ScWUft8dUXfu6rOv9HRN3j2CmSSZbD3+Gk2ExHg2CqPFKf1I+2krGO3OoOXMamGrAxAysHOk4uAFp5/LYvzqOof9ug429RaWua2epYelIf5797BCvfBfNV2PbYCqb9AohxCPp8vvvU3LqdJWOadGkMTVff/2mx8ydO5f169fj5eWFi4sLAQEB7Nq1i0WLFhEYGEhWVhaBgYEkJydjMBiYNWsWoaGhlJSUMGXKFCZPnkxaWhpDhw4lPz8fvV5/rV3W+PHjiYiIQFEUxo0bx/Tp08utwc7O7tq/FxUVVdmz3RLcHmOu1q588MxnDN01lHfbDeYj6yYo0RuokbkUp0Z25GzZjXXGOuxq666eYO+F2eA1BE9oxqb5EexfHUffl/xQKhm8mnnY807fZszecoIXvz7Gf4e0ooalvGkqhBDi7kVERLB582aioqLQ6/X4+/sTEBBQ4fErV67E3t6e8PBwSkpK6NChA8HBwWzZsoWQkBDmzJmDwWBAq9USHR1NamoqsbGxAOTm5t60ljlz5rB27Vrs7e359ddfq2R+Etwecw0cG/BS65f477H/sqNDd/r94w9Ii8bt8hm0/15BWpQlVoOeR+NoCYeWwOruOPf4Dx2HBBO6/gxHdycR1NPntnud/s+wIC90ZQbm7T5FvyVhfD4qgIbuNe7RLIUQQjwIt1oZuxcOHjxIv379sLK6ugNCnz59bnr83r17iYmJYdOmTQDk5eWRkJBAUFAQ48aNo6ysjP79++Pn54evry+JiYlMmzaNXr16ERwcfNOx582bx7x585g/fz5LlizhnXfeuev5yTNuglFNRxHgHsD8o/O5VJQGHq1R/Ifh+flqwJTUNUdQA8bD5N/A50nY9QpNs96nvr8zEbuT+Wr2IX7/Lp70pHxud3sZRVEY26EuGya2I1+np//SMHbFVM2Dm0IIIR5fFf1/yMzMDKPx6q4IOp3uuuM//fRToqOjiY6OJikpieDgYDp16sSBAwfw9PRk1KhRrF27FkdHR44fP07nzp1ZunQpEyZMuK2aRowYwebNm+9+ckhwE4CpiSnzOs4D4N9h/8aoXv0P29zbm5rvvkNxVBSZny65ulnvyI3w1Gsox7/mGcNLdB/pTq169sT+nsqmhRGsf/MwYZvPErXvAid/TyUhIp3zJ7PJvFhQ7h+mNnWd2P1SR5rUsmPqhije2xXHkcRsfoq9zLdHL7As9BwLfjzNb/GZ9/VnIoQQ4uHUsWNHdu7ciU6no7CwkN27dwPg4+PDsWPHAK6trgGEhISwbNkyysrKAIiPj6eoqIjz58/j5ubGxIkTGT9+PJGRkWRlZWE0Ghk4cCBz584lMjKywjoSEhKu/fuOHTto3LhxlcxPbpUKADxtPXkt6DXePPQm6+LWMabZGADse/VCe/gw2cuXY9O2DTbt20OX18HDH9Otk6h3uB/1XjhIiWljzkVlkhCezvH9FyjvLzxNOtTiqWGNMNVc//cFdztLvpnYjnm74/jyYBJfHky67tdNFPj8t3M83diNN3o3xcfF5p79HIQQQjzcgoKC6Nu3L61ataJOnToEBgZib2/PjBkzGDJkCOvWraNr167Xjp8wYQLJycn4+/ujqiqurq5s27aN0NBQPvjgAzQaDba2tqxdu5bU1FTGjh17beVu/vz5FdYxa9Yszpw5g4mJCXXq1OHzzz+vkvlJ5wRxjaqqvPzry4SlhrEieAWNnRpjZWaFqtORNHgw+svpeCz6gBqdO189IT0OVnQF73bw3BYwuRrIVKNKWYmBUp2e0uKr/0w6nknkngu417Wjx+QW2DiU/zZq1IUraEsN2FtpcLQxx9Fag5mJCavDkvjk5wTKDCoTO9VlSpf6WJvL3zuEEKK6qQ6dEwoLC7G1tUWr1dKpUyeWL1+Ov7//A62pItLyqhwS3G5fdnE2A3YMIEd3dYNcC1MLnCyd8NHZ8tyaFFxSCsgZ1R3nSRPxcaiLVfS3sOsVCH4P2k+76djnIjPYv+YU5hamdJ/cglr17CtVW3q+joU/nmZLVCq17C2ZP6AFnRu53fFchRBCVL3qENxGjBhBXFwcOp2OMWPGMHv27Adaz81IcCuHBLfKuVR4ifDL4eTocq59ZeuyycxJocd3SXQ4aeSPxgrLepnSyLMVH+aV4pbwC0zYDx5+Nx07O7WQHz4/QWGOjk7DGn/80IkAACAASURBVNLsSc9K13fsfA6vb4nlQo6W7VM7yNuoQghRjVSH4HY/TZkyhbCwsOs+e/nllxk7duxtnS/BrRwS3KpOqb6U5C8Wo1+6mqLaTnwQrMPRzJbZSenY6zToGz8PphocRwzHzMWl3DF0RWXsW3WSCydzeGpEI5p3qnx4y8jX0fOTg9hZmbFjakdsLeS2qRBCVAePW3C7WxLcyiHBreoVHgwj9dVXMeblXf8LCqCYYGJlhcuLL+A4ejQm5uY3nG80quxacpy0s7kMndMGB3frStfwx7lsRn55mF4tPfhkmF+V7UothBDizklwq5zKBjfZDkTcEduOHfDdspla781F+c/rvD/JkVkvWWEyIhPfxa9gHRRExqL/kti7DwU//3zDViAmJgpPj26CqcaEfatOYjAYK13DE/WceTW4ETuPX2Ld4fNVNTUhhBCi2pLgJu6YxtMTh0GDaNx3FO+M/5pCFwfGe3lwNvo9vIbUxuvTD1DMNaRMmcrF8eMx/K01iI2DBZ1HNCbjfAERPyTfUQ0vPlWPro3dmLsrjuiLN289IoQQQjzsJLiJKuFr78tXPdZga+POBDcHzh/6CNvDY/EdWxv3l8ZRFB7BpVmzUY3Xr6zVD3CjUbuaHPvxPJcT8yoYvWImJgofDmmFWw1LpqyP5EpRaVVNSQghhKh2HsrgpihKf0VRViiKsl1RlJs3ChP3jVcNL1b1WIOJuS2vNX+SstajUE5vxynjPdw72VAYGkr2SyGwcSxsGg/bp0D6SZ4c2hBbBwv2r46jVKev9HUdrM1Z9pw/mQUlvLj+GHnasnswOyGEEKLyFi1ahKIoZGVlVcl49/1VPEVRVgG9gQxVVZv/5fPuwGLAFPhSVdUFFY2hquo2YJuiKI7AImDvva1a3C4PWw/ebv82/wz9J0ubP8UrT8fBsTU4ntxK8UUNmT+nYGWbhY2HAkWZcGITFj0X8czzvdn6URRhm8/SZWTl24K0rO3AwkEt+NemGPouPcjyUYE0qinbhAghxIP0+/fxZF0srNIxXbxseXJIwyod8165ePEi+/btw9vbu8rGfBArbl8B3f/6gaIopsBSoAfQFBiuKEpTRVFaKIqy629ff91x9d9/nieqkW51ujGwwUBWxa7iaG4CdHwFZfJv1NzwB+Y+dUk9aEvZsJ9g2jHwags7puJxcjatu9Yi7vdL/LbhDKlnrmCs5AsLz7auzbeT2qEtNUjTeiGEeIzNnTuXxo0b061bN4YPH86iRYvo3Lkz/9thIisrCx8fHwAMBgMzZ84kKCiIli1b8sUXXwCQlpZGp06d8PPzo3nz5vz+++8YDAaef/55mjdvTosWLfjoo49uWsf06dP5z3/+U6W7Htz3FTdVVQ8oiuLzt4/bAGdVVU0EUBTlW6Cfqqrzubo6dx3l6k9gAfCjqqrldnhVFGUSMAmo0qQrbs+/gv7FsfRjzD44m819NuNg6YCprQ21P1lM0pChXPrnq3h/tRpl1Fb47T/w20LaOsdQ1Oq/nPojjdgDqVjaaqjbygVfP1dcattibmWGxtwUxaTiPwABdZzYNa0jL359jKkbojiRmsfM4EaYmV79O0qZwcgVbSkmioKLbfltt4QQQlSNB7EyFhERwebNm4mKikKv1+Pv709AQECFx69cuRJ7e3vCw8MpKSmhQ4cOBAcHs2XLFkJCQpgzZw4GgwGtVkt0dDSpqanExsYCkJtb8UtxO3bswNPTk1atWlXp/KrLrqWewMW/fJ8CtL3J8dOAZwB7RVHqq6p6Q+dWVVWXA8vh6j5uVViruA3WGmsWdlrIyB9G8vYfb/NR549QFAWLBg2o9fZbXHptFpmLF+P26qvQZTZ4t8V080S6lQ3gqX+s54K2OYnRmZw7lsGpsLT/H1gBc0szzK1M8WnuQofB9THTmF53bXc7S76d9ATv7DzJF78l8sOJq+fnFpVRUHL1GToTBUa09ebVbo1wtLlxnzkhhBAPp4MHD9KvXz+srKwA6NOnz02P37t3LzExMWzatAmAvLw8EhISCAoKYty4cZSVldG/f3/8/Pzw9fUlMTGRadOm0atXL4KDy3/MXqvVMm/ePPburfonuapLcCtvCaXCsKWq6ifAJ/euHFEVmjo35RX/V1gUsYhNCZsY3HAwAPb9+qGNjCJ7xZdoPDxwHD4c6nWFFw7Cumcx3zWJ+i/+Qf2AZhjKjKQmXKEgW3etYX1JsR5tXgmxB1LJvFhQbtN6czMT5j3bgtbejvxwIg07S7M/m9ab42hjztn0Ar4+coGdx9OYEdyQ4W28r63KCSGEeHhV1FjAzMwM4587G+h0uuuO//TTTwkJCbnhnAMHDrB7925GjRrFzJkzGT16NMePH2fPnj0sXbqU77//nlWrVt1w3rlz50hKSrq22paSkoK/vz9Hjx6lZs2adzW/6hLcUgCvv3xfG5AHlB4Bo5qOIiw1jPlH5rPz3E7crd1xt3an5rN1aJrUlMvvvEtxYiK1Zs1CsasFg1bC8s6w8yUYtgFTjQneTZ3LHft/Tes3zg+nxwstca9rd8MxgwJqMyigdrnnj2hbh7d3nOSN7SdZf+QCb/dtRjvf8q8lhBDi4dCxY0cmT57M7Nmz0ev17N69m4kTJ+Lj48OxY8do06bNtdU1gJCQEJYtW0bXrl3RaDTEx8fj6elJVlYWnp6eTJw4kaKiIiIjI+nZsyfm5uYMHDiQevXq8fzzz5dbQ4sWLcjIyLj2vY+PDxEREbhU0AqyMqpLcAsHGiiKUhdIBYYBIx5sSaIqmCgmvP/k+yyJWsKFggvEZcfx68VfKTGUoHRRGa0q9Fr3NYePbuGPyU/gXasRg5+aQc1f3ofINRDwfIVj1/N3w97Nmh+WxbD1v5F0ea4RjdrVuu3aGtWswYaJbfkp9jLv7T7FsOWHWTbSnx4tbn8MIYQQ1UtQUBB9+/alVatW1KlTh8DAQOzt7ZkxYwZDhgxh3bp1dO3a9drxEyZMIDk5GX9/f1RVxdXVlW3bthEaGsoHH3yARqPB1taWtWvXkpqaytixY6+t3M2fP/++z+++9ypVFOUboDPgAqQDb6mqulJRlJ7Ax1zdDmSVqqrzquqa0qu0elFVlbySPC4VXSI5Lxndpu00+up30l01vD8IlJpuLNeaUTclGuPz+9Eb7TBzdy+35ylAcWEpe5bHkhqfS2BPH9r29a10TcWlBoatOExiRiE7p3XEx8XmbqcphBCPperQq7SwsBBbW1u0Wi2dOnVi+fLl+Pv7P9CaKiJN5sshwa36KwwLI/WV6RjNTIh1KcYhz0DtPD2UXH38UePhgeur/8SuZ89yX6s2GIyErj/D6UNp9PpHS3xaVn45OuWKlt6fHqSWvRVb/9Eey7+99CCEEOLWqkNwGzFiBHFxceh0OsaMGcPs2bMfaD03I03mxUPJtkMHfL79BisfX1qYeHPFScOvzTWUtS6i5vC2mNjZcenVGZwfPoLi48dvON/U1ITOwxvhXNuWX9adQptf+dZXtR2t+WioH6fS8nl7x8mqmJYQQogHYMOGDURHR3P69Ol7HtqmTJmCn5/fdV+rV6++Z9eTFTdRLaUVpjFp3yTS8y/w8eV0nuj1BXmnyshYvBhDVhZ2vXvjNnMGGnf3687LvlTIxvkR1G7kSK8pLe9o08MP9pxm6a/nWDS4VYUvNgghhCjfqVOnaNy4cZVuOvuoUlWV06dPy4qbePjVsq3F6u6r8XbwZYq7K7/vnoRD+n+oN28YzhPHUbBvH+dHjcZQUHDdec4etrQfUI/zsdnE/pZ6R9ee/kxD2vk68e9tJzh9Ob8qpiOEEI8NS0tLsrOzK9yWQ1ylqirZ2dlYWlpW6jxZcRPVWn5pPhN+Gk9KfjJbtJbUvBQDFnZo7bpzfukharRrgefsCSimZqCYgHN91Bq12LXkOKnxuQx5PQinWpV/0SCjQEevTw5Sw8KMrVM6YG+luQezE0KIR09ZWRkpKSnX7ZUmymdpaUnt2rXRaK7/f4y8nCDB7aF2If8Cg3YOorlzc1Y0nYzp0eUQt43sOAsyou1x98/DqWHR1YM11tD7Y4p8+vPt3KPYOlow6LVATM0qv7h8ODGb5748greTNV+MCqCBuzStF0IIce/JrVLxUPO282Z2m9mEp4ezJv/k1U16/3kap0U7sG3XmvQYJ4qfWAqjt4NHa9g6CZsD/6LL8HpkXSzk4MYESor1lb5uO19n1k9oS76ujP5Lw/jxRNqtTxJCCCHuIVlxEw8FVVV59bdX+fXir3zd82uaOTcDwJCbS9KAgQDU3bIZ0xq28MtcCPsYarbkN4sPiT1SgImZgncTJ+r5u+HT0gVLm9u/9Xk5T8cLXx8j+mIu/+hcj1eDG2F6k0b3QgghxN2QW6US3B4JeSV5DNgxAGsza77r/R3WGmsAimNiSB75HLYdOlD7s6UoJiZw5kfYOhnVCOntvuBsTn3ORWZQmFOCiYlCzXr2WNXQYG5l9mfTejNs7M1p1K7mDU3rAUr0Bt7eEcc3Ry/wZAMXujZ244q2jFxt6bV/PlHPmXEd6sr+b0IIIe6KBDcJbo+Mo2lHmbB3AoMaDuLNJ9689nnOuq9JnzcP11deweWFyVc/vJIM34+B9FgYvxfVw5+M8wUkRmWQGp9LabH+6pfOQFmJAQD3unb0eKEFNvYW5Vwdvjl6gbe2n6TUcLXdib2VBkdrDRZmppxJL6COszVv9GrK003c5FV4IYQQd0SCmwS3R8qHER+y+uRqpvpNpYlzE9ys3XC1cqV4zjwKfvgRp7FjcZvxKoqpKRRfgWUdwcwCJh8AC9tyxzQaVRKjMvl57SksLE0rbFoPkFdcht5gxN5Kg5np/z8meiA+k3d2nuRcZhFPNXTlzT5Nqeda/vWEEEKIikhwk+D2SCkzlDFuzziiM6Ov+9wcUyaHWvDkH/lk+HlTMGcCdT2aUu/KZSy/Hgj+o6HvJzcdOyulkB+WxaDNK6Xzc41oXImm9VdrM7LmUDIf70+gRG9gVo8mjO9Yt9JzFEII8fiS4CbB7ZFjMBrI0GaQrk0nsziTDG0GGdoMUgpScPkpgj7bM0h1hoWDTTHUdGaZbSuahq+BoeuhSe+bjl1cWMqeFbGknsml1TNetB9QH5NKvoyQUaDj9S0n+Pl0BmvGtqFTQ9e7ma4QQojHiAQ3CW6PnbyDv3Np+nQMJrC+mwWlZcWMyVJxyy6kzP0pMLXAeeIErFu3Lvd8g8HIoU1nifk1hcCePrTt61vpGopLDTz7WRjp+Tp2v/QkHg5WdzstIYQQjwEJbhLcHkslSUmkvPAipefPX/vMaK5iZW+J3miLITsbu549cXv1n2g8Pcsd4+c1cZw5fJlnX/WnVn2HStdwLrOQvp8epFHNGnw3+Qk0prJ1ohBCiJuT4CbB7bFlLCpCd+YMBTYmvHLiXc5oE/nP5ct0bfM62TGQvXIVAE5jn8dl4kRMbK5vj1Wq0/Pde0cBGDqnDeZWZpWuYVfMJaZuiGJ8x7q80bvp3U9KCCHEI006J4jHlomNDdb+/rg38uPzPqtp4tyMV91d2RWxENdaUdRb+T41uj1D9udfcK5HT0qSkq4739zSjGfGNqMgW8fv38ffUQ29W3rwfHsfVh5M4qdY6b4ghBDizklwE48Newt7VgSvIMgtgH+7OnH0QiiaXcPxbBBOnXfHopaWkvryKxiLi687r1Y9ewJ6+HD6j8ucPZZxR9d+vWcT/LwcmLkxhuSsoqqYjhBCiMeQBDfxWLHWWPPJM59Rx86H2V51yev+PpQVYx03D4/ANEri47k8PAAW+8En/lf3gDu5lcBePrj52BG6/jSFV0oqfV1zMxOWjvTH1FRh7FfhnM0ovAezE0II8aiT4CYeO9YaaxY8uYAc3RXe0Z1D/cdhGLUN2+7P4tylDnmnVXIzvKBWK0CFjc9jumcW3UY3wKA38vOaOFRj5Z8N9XSw4svRgeQXX21av+fk5aqfnBBCiEeaBDfxWGrm0oypraey7/w+tp3bDvW6QO+PcF2yG+u2bbm8OwVdy9kw8Vdo9w84+gUOu5+lY29nUk5fYdPCCKL2XiA/q/jWF/uLQB8ndr3UkXputkxed4xFe85guIMQKIQQ4vEkb5WKx5bBaGDivonEZsWyqc8mvO28AdBnZpI4YACmtjXw2bgRU1sbiNsO26eiYkJM3S85k+hA5oUCAFy9a+Db2hWX2rZ/aVpvioXV1eb15fUs1ZUZeHvHSb4Nv0jnRq58PNQPExOFK0VXm9Zf0ZZibmpC+3rO0vNUCCEeM7IdiAQ3UYHLRZcZuGMg3jW8WdtzLRoTDQBFR45yYexY7Lp3x+O/i66Gp+xzfzatPwF9l5DnNYjEqEzORWWQnpRf7vg1fe3pPqk5Ng7lN63fcOQCb+2IpcxQ/p/DgDqOvNO3Gc097atmwkIIIao9CW4S3MRN7Enew4zfZjCxxURe8n/p2udZn39B5scf4/jcc7jPeg3FzAzKimHDULh4FF74HVwaAFCUV0JhTgmlxXpKdXpKivVo80o4tufCLZvWx6Tksi8uHTtLDQ7WGpxszHGwNichvYAP9pwhR1vKsCBvZgQ3xNm2/AAohBDi0SHBTYKbuIU3wt5g29lt2GpscbN2u/pl6cqTW89R58cY1LZ+eH/0MbZO7pCfBsueAEcfGL8PTDUVjnu3Tevzisv45OcEvjqUjI25Ka8GN2L0E3Xk9qkQQjzCJLhJcBO3UKwvZnP8Zi4WXLzWsD5dm05WcRadI8sYv9fIZUf4aowHDvUaM7FGE/x+mANPvgpPv3nzsf/etP7ZephUsvVVQnoB7+yM4+DZLF7v2ZhJnerdzXSFEEJUYxLcJLiJO1RmLONiwUVSQn/C4d3lGDCybKgdUR4lfGzmS1DEfvRdP0RvWgur5s0q7HlqMBgJ23iWE6Ep+Pq50n1y80qvmqmqyj/WR7I3Lp1vJ7UjyMepKqYohBCimpHgJsFNVIHS5GQuvvgPSi9eoNASbAsN1/26Ym6O05gxOE+ehKmtbbljRO49zx9bzvHk0Aa07OJV6RrydWX0/fQgxWUGdr/0JC7yzJsQQjxypFepEFXA3McHn+++xXHYcNxCenMgpBZf9DAlJUSLz4utsOvRnewVKzjXvQdXNm5ENRhuGKN1N2/qNHfm0JZzZF+qfPcEO0sNn40MIFdbxsvfRskecEII8ZiR4CZEJZja2VHz33OoM28BoxbtoqjHE/zT344tht/xCKmBz9oVmHt7c/mNN0kaOIjimJjrzlcUha6jm2Buacr+1XEYyoyVrqGphx1z+zUn7Gw2i39OqKqpCSGEeAhIcBPiDllrrFny9BK6enVhgbMTG6KWYbV3EHWGOuH51j8x5OVxYeIkylJTrz/Pzpwuo5qQdbGQIzsS7+jaQ4K8GBRQm09/SeC3+MyqmI4QQoiHgAQ3Ie6ChakF/+38IZ1rd+YDV1dONe2BcmIjdmdmUKevBkq0pEwYgRr6Xzj0KfzxGSQfpG5LF5o96UHU/guknLlyR9ee2685jdxr8Mq3UZzLlKb1QgjxOJDgJsRdMjMxY26HuThZOvOaSTbFL0XCM+9gziVqBaSjS8og/cOPYe+/Yc9s+KoX7H2DDs/64OBmzc9fxaErKqv0da3MTflspD+KotB/SRj749LvweyEEEJUJxLchKgCDpYOvNfxPZLykvhv3Cro+Aq8EoPd8hQcnxvBlXhb8oPWwr+SIHA8HPoEzbf96TbEFW1eKftWnSQ9KZ/KvuXt62rLzmkd8XGxYcLaCD7cF49RXlgQQohHlmwHIkQVWhS+iDVxa/ikyyd08e4CgFpaSvJzoyhNTKTu5k2Y16kDMRth58ugseK4zwoOhSoYjSq2ThbU83Ojnr8rNX3tUUxub683XZmBf2+LZdOxFJ5u7MaHQ/2wt6q4o4MQQojq65Hcx01RFBvgAPCWqqq7bnasBDdxv5QaShn5w0jSi9LZ3HczrtauAJSlppI4YCAaDw98vtmAiaUlZMbD96Mh8zS6jm+TbDuUc5GZXIzLwaA3Ym5lhqWtBgsrM8wtTTG3MsPG3oLAXj7Y2N+4f5uqqnx9+Dzv7IyjtqMVQT5OXNGWkastJUdbSn6xnifqOTO7R2M8HKzu949GCCHEbapWwU1RlFVAbyBDVdXmf/m8O7AYMAW+VFV1wS3GeRcoAk5KcBPVSWJuIkN2DSHAPYBlzyzDRLn6REJBaCgpL7yIXd8+eLz//tWm9aVFsGMaxG6GoV9Dkz6UFutJjs0iLSGPkj+b1pcW6yktNpCbocXS2uymTevDk3N4bVMMxWUGHKzNcbTW4GhtjoWZCbtPpGGiKEzpUo8JT/piqTG9nz8aIYQQt6G6BbdOQCGw9n/BTVEUUyAe6AakAOHAcK6GuPl/G2Ic0BJwASyBLAluorr57vR3vHfkPbrV6UYjx0a4Wbvhbu2O87e/YFyxHpsOHfD86ENM7exAXworn4HcC/DiH2BXcSP6vzat7/JcIxpVsml9yhUt83af4sfYy3g5WfFGr6Z0a+ouTeuFEKIaqVbBDUBRFB9g11+C2xPA26qqhvz5/WwAVVX/Htr+d/48wAZoChQDz6qqWuFOphLcxP2mqipzD89l7/m95JXkXfdrXY4bmfSTkTxXa47P7EWtRq1pbeaIz/ph4N0OntsCJhW/N1RcWMqe5bGkxufi94wXT9xB0/qws1m8veMkCRmFDAvyYv6AFhLehBCimngYgtsgoLuqqhP+/H4U0FZV1am3GOd5KlhxUxRlEjAJwNvbO+D8+fNVOQUhbptOryOzOJMMbQYZ2gwuFlyk8MgROi07glE18N9nTYiva85/PELo9vsy6L4A2r140zH/2rTeq6kT3Sc1x9zSrFJ1lRmMfLDnDMsPJDLv2eaMbFvnbqYphBCiijwMwW0wEPK34NZGVdVpVXE9WXET1VHphQtcfOFFSs+f53AnV3IKM+hYaIl7Zh5lprVQTM1xnjQJh0EDrz4PV464g5cI3XCGhkHuPDO2aaVrMBpVxn4Vzh/nstn8Ynta1La/22kJIYS4Sw9Dk/kUwOsv39cGLj2gWoS4L8y9vfH57ltsOnag3a+XeeY4FKRrSbc0w8YxH7Oa7lx++22Snh1AYVhYuWM07ehBYI86nDlymYSIym/Aa2Ki8NFQP5xtzfnHhmPkaSu/EbAQQoj7p7oEt3CggaIodRVFMQeGATsecE1C3HOmNWrg/cUXNIo8RuPISHbNC2HCKA07O+fgPdITz8WLMRYXc3H8BC6+8CIliUk3jBHY0wf3unb8tuEMBTm6StfgZGPOkhH+pOXqmLHpeKU3ARZCCHH/3PfgpijKN8AfQCNFUVIURRmvqqoemArsAU4B36uqevJ+1ybEg2JibY2FmQWLnlpEH98+LHF04OOz31MjYQ6+7w7EbfpLaMPDSezXj6KjR68/19SEZ8Y2xWBQ+XlNHOoddE4IqOPI6z2bsC8unRW/31njeyGEEPfeQ7sBb2XIM27iYWJUjbx/eB7fxX/PvDJb+qbEgYU9+vqDOL8iBoNWh+83azBzcwPFFEw1YKohLuwSv647zRMD6uEfXPkXDVRV5R/rI9kbl843E9vRpq7TPZidEEKIW3kYnnETQvzJRDFhdtvXCXAPYJ6VkYvDN0CDbpidWoNn0yiMVzJJHdkNdV5teL8WzKsJv7xHk3Zu+Pq5cmR7IpkXCyp9XUVR+M+glng5WjF+TTi/nJam9UIIUd1IcBOiGvo/9u47Oqpq7eP490xLJoX0EAgJhISW0EEQBESpIqA0QURBQQERVFBBsV29drxWFFBQkSYKKs0CIlVQegk9CZCE9J7MJNP2+0eQVyUgCQn1+ayVxZ2T2W3WuvjjzNn70ev0vNbhNfQ6PVOOLcDefwY8th/3YW8RMqI7lnQ3Mq19oOuLEH0HbHgLbV4/OvcLwN3LyOrZsdhLnOUe19vdyLxRbQn392DkF9t5b81RKVovhBBXEAluQlyhanjV4Pl2z7M3cy+z9s4qrajQ+gF8n/wAnwH9yVyxk0J1AwycA3dMh8RtmL+8hS49FTmpFj6bvImfZ8cSvysDh+3CQ1wtPw+WjG1Pv+ahvLPmCA99uYP8YtltKoQQVwJ5xk2IK9zUTVNZEb+Cz3p8RsvqLQFwWa0cHzwER3o6Ed8uxVijBqTFlhatz44nOeZ1Dhd1JH5vJiVFDgxuemrHBBBYyxOT2VD64176Z1C4N27ms8+JU0rxxW/HeXnlQWr7e/Dffo3R0M4Urc+12DHpdQxpE4a3u/FSfyxCCHHNuuIO4L3UJLiJq1mhrZBBywfhUi6+6fsN3iZvAEriEzg+cCBuDRpQe+4XaEYjlBTAsgkQuxQ6TMR5y3OcOpJL3K4MEnZnYMm3ndW/p68bt41pQvU6ZRet/z0+i3ELdpJZeHZbgEAvN6bc1pD+LULR6aRslhBCXCwJbhLcxFVuT8Yehv8wnG61u/Foy0cJ9gjGpDeRv2oVyRMn4dm+HaHvvIPexweUgmXjYdc8GLEC6nQ404/T4cJW7MBmdWCzOinKLWHDV0dKi9bf25AGbUPKHD+joIQdJ7Kp5m7E18OEv6cJXw8jh1MLeGFZLLsTc2ke5st/+sbQLMz3Un0sQghxTZLgJsFNXANm7JnB9N3Tz7z2c/Mj2COYTnuddFl4BHuIP9qbzxDR5CaqKR3M7AhOO4zZBOZzh6m/Fa3vFl5atL4cd85cLsW3u5J57YdDZBWVMLh1GC/2jcHdqL+o9QohxPVKgpsEN3ENUEqxPW07SQVJpFnSyLCUFq5PtaRi2hfHhK+t6BS83U9HRnQIE+r04Y5VL0Hj/jDg0/P2/c+i9d1HxuDuWb7n1gqK7Xyw9hizNsQztG04r/ZrcjHLFUKI65YENwlu4hrnUi6SDu8g77Ep6BJT+alfLb4LSeYxrRFdd23AUf9eHKZaeLRqjVfHDufs0t3nSgAAIABJREFUJ3ZjMhsWHcG/picDnmqFoQJ3zV774SAz18fz7uDm3Nki9GKWJYQQ1yUJbhLcxHXCWVhI8qRJFK3fcM73eHbsSPXJT+EWFVXm7xP2ZLDq43006xpGh4H1yj0Hh9PF0E9/Z19SHsseuYl61b3L3YcQQlzPJLhJcBPXEeV0kvfddzhKivk6ew0/FG6jq66Ecb51ydXfReaMmbgsFvwGDyZw/CMY/PzO6mP9gsPs35BM38eaE9aw/KWv0vOL6fX+Rnw9THw/7iY83c4+bkQIIUTZpOSVENcRTa/Hd8AAAofew+hxs7nxlqF8Ut2dl0uO4GteQ+Sc1/AdNIicRYuI69GTvBUrz+qj/cAo/EI8+OXzgxQXlf/w3eBq7rw/pAXxGYU88+0+rod/IAohxKUgwU2Ia5hO0/F0m6d5sMmDLKnmxZs5OzAs6U+Nmuuo++YY3OpGcOrpp7Hu2/e3dkaTnm4PxGDNt7Fu/qEKBa/2UYE83rU+3+8+xfzfT1bWkoQQ4rom318IcY3TNI0JLSdgdViZd3Ae7RuO4+aDq3Hb/ixhjYOIT/Ak+cFhRDzcFL2nO+j0UKM5QW0eok3fCLZ+F8/hrak0bFej3GOPuyWK7SdyeGn5AUJ9zdzSMLgKViiEENcPueMmxHXi8VaPU9+vPs9nbibz/lUwbCn6yDbU6m7Enm/j1PydqMTfIX49/DgZ5g+kxU1e1Kzny4ZFR8jLsJZ7TJ1O453BzYkM9uKBL7bx4VopWi+EEBdDgpsQ1wmT3sQbHd+gyF7Ec1ueR0XeCncvwPzydqo/PZXCEy6yvR+FiQfg9v/B8Y3oPulE1x42NJ3Gyo/2ErsxucyyWefj72li6dj23NGsJtN+PsKYeTsokKL1QghRIRLchLiORPlFMan1JDYlb2LhoYVnrvsNuwfvHj1I/987WHbuhBtGwsjVoDPgvfR2urWPx+VwsW7+YT6fvInv/reTfeuSyMuwYit2/OszcGaTnncGN+e53tH8ciidO6dv5lh64d/eU2x3kp5fjFPuyAkhxDnJcSBCXGeUUjyy9hG2ntrKV72/Isqv9Dw3Z0EBCQMHoqzFRHz3LQZ/f7Dmwvfj4NAKVHR/sm58j7jdmcTtyiAnpehMn5oGJrMBk7sBT18THe6qf86i9VvisnhkwU6K7U5qB3iSa7GRbbFRbHcBUL+6Fy/2iaF9VGDVfxhCCHEFknPcJLgJ8TdZ1iz6L+tPoDmQBbcvwE3vBkDxwYMcHzwE9yZNCJv+IXpf39Ki9Rvegl9fge6vQPtHAMg+VURKXC4l1tNF64ud2KwOkg/nYC2wn7do/alcK6+sOkixzYmvhwk/DyN+nibcDDo+/+04STlWejUJ4Zlejajl53HJPhchhLgSSHCT4CbEWTYmbeThXx4myjeKCJ8Igj2CCfYIps72FELeXoShRg1qz5yJW0REaXhbdA8cWw0P/gohjc/Zr7XAxk+fVLxofbHdyScb4pm+7hgAY2+OYvTNdaVovRDiuiHBTYKbEGVadGgRa06sKS1ab82gyF769WeDJMUTS5wYXRorH4jG0LYlbf2i6bLsKfAIKA1vRvdz9ut0uti8+Cj71icTHu1PtwoUrU/OtfLqqoOs3JtCmzr+zH+wLUa9PJYrhLj2SXCT4CbEBSmyF5FmSSOpIImkI7uIeGUB1VLy+bKnOyubOXg4rCdjNsyCNmNwtX8apVSZJbP+9GfRem9/d+54vAXe/ucOe+fyzY4knvh6D6M71eXpXo0uZnlCCHFVkOAmwU2ICnEWFnFq0iQK168nJTqY7MJ06hQa8corQTl1oNPhe9cggiZMKN3MUIaUY7ks/2APQeHe3PF4i3J9bfqnZ7/bx7ytJ5l1byu6x5T93JwQQlwrpFapEKJC9F6e1PpoOgEPPkh4oTvV3YPZXd3BoeZGgtq68BtwB7lff0Nc9x5kzZ6Dy3b2GW81onzpNKQ+p47msnt1xUpfPdc7miahPkz6eg8nsywXuywhhLhqSXATQpyXptcTPGkiUT//RIfv12F9fizPddd4o62TgIbHqPvVXMytWpL+1lvE9+5DwZo1Z/XR4MYQIlsG8fuyeDJOFpR7Dm4GPR/d0xINeHjBDortzkpYmRBCXH0kuAkhLpimaYxvMZ5JrSbxo6eZx/J3ov+uF+G93Ql761k0k5GkR8aT++13Z7XrfE9DzF5GVs+JxW4rf/AK8/fg7buasz85n5dWHKisJQkhxFVFgpsQotxGNB7B1LZT2eBh5pN6N8CeRXjteJi6/cEjJoLUF5+n+NdFcOI3OLkVUvbi7mGgy4hoclIt/LbkWIXG7RZdndE312XB7ydZsiOpklclhBBXPsPlnoAQ4uo0pOEQ9mbsZUbCStrd9zXNT+5A++NTakadIiEuiOSnniWieyY64+kNUA16EXbnRzTrGsaeNYnUbhxAnSblr47wZPcG7D6ZyxPf7CGtoJixN0eiaeXf8CCEEFcjueMmhKiwZ9o+Qw3PGkzZ9iqFbR6ER/dgHL+G0P9MxlZkIiWzD+qeJdD1RTi6GmZ24sYb8gkI9WTt3INknSr8tyHOYtDr+Oz+G+jdtCZv/niYcQt2UljiqPS1CSHElUiCmxCiwrxMXrze8XVSilJ49fdXQW+AWq3wvGMkQRMmkL9+O7k7MqHD43D/D+ByYZjbk25tDmEvcbLopT9Y+NLv/LE8nqzkwn8tVv8nD5OB94c0Z2qvRvy4P5V+0zcTn1H+ECiEEFcbOcdNCHHRPtr9ER/v+Zg3Or5Br7q9AFAuF4mjx2DZupXaixZijokBSzYsfQiOraao3jDigicStzePlGO5KAW+1T0IqOl5pmC9yazHZDYQ1sifgFCvMsf+7Vgmjyzchd3h4tGu9QDItdjJsdjItdgxGXQ83DmSetW9L9nnIYQQF0MO4JXgJkSVcrgcjPhxBPG58XzT9xtqetUsvZ6TQ0K//mgGA3W+XlxaZcHlgs3vwNr/QvSdMHAOlgI78bszSNiTQUF2SWnReqsDe0np7lO9QXfeovVJORbGztvJvuS80vfrNHzNRnw9jKQXlGC1ORnevg6Pdq1HNffyld4SQohLTYKbBDchqlxiQSKDlg8iyjeKETEjzhSt9zycRPKIkRhCQgib8TFudeuWNtjwVml46zcLmg0us0+XS2HJK2HNZwf+tWi9w+niVG4xPmYj3u6GM+/JKixh2s9HWLTtJAGeJp7q2ZCBLWtVqIKDEEJcChLcJLgJcUmsjF/J1E1Tcar/P6dNp+m4Ib0aYxblYXRC4lODqX5LdyKr1cF/4TBIPwBjNoFf7XP2WxlF6/cl5fHCsv3sPJlL8zBf5oy4AX9PU4XXKoQQVUWCmwQ3IS6Z3OJcThWdIsOSQZoljXRLOqlFqWQfP8Sdsw5SM8PF5111/NRax/DIO5m04TO0kMYwYiXo9Oft+0zR+gB3eo1tin8Nz3LNTSnFt7uSmbJ0HzfWDeDzETfInTchxBXnmgtumqbpgJeBasB2pdQX53u/BDchrgyOwkKOPz4B+8YtHLslkq8DE+jqqkWPQ7E4/Vrh0IfgecMN+N17Lzo3tzL7OHUslx9n7kPTaQx5rg1mr/LfNZv/+wmmfrufid3qM6FLvYtdlhBCVKorqsi8pmlzNE1L1zRt/z+u99Q07bCmacc0TZvyL93cAYQCdkCOTxfiKmHw8iJyxif4j3yAqF/jePprFzcsOUlWrDeFOw5iTzhG+rS3ib+9N/k//lTm8SA1o3zpM6E5xYV21s0/fMFHiPzV0Dbh9GsRyjtrjrDpaGZlLE0IIS6JS37HTdO0TkAhMFcp1fj0NT1wBOhGaRDbBtwN6IHX/tHFA6d/cpRSMzVN+0YpNfB8Y8odNyGuPNb9seCw813eRt6Im0k7J/yv2ISr2dukTXuXkiNHMLduRfUpT2NuHHNW+50/n2DL0jhuubch0TfVLPf4FpuDOz7cTHaRjZUTOhLi414ZyxJCiIt2Rd1xU0ptALL/cbkNcEwpFa+UsgGLgDuUUvuUUr3/8ZNOabjLOd22zGrVmqY9pGnadk3TtmdkZFTVcoQQFWRuHIO5eXPuvnk8Uzu8wGaTjrHGAtTeJ4mY2puQ56diSzjO8YEDyXj/g7PaN+8aTmh9XzYuPkpehqXc43uYDHw8rCVWu5PxC3did7oqY1lCCFGlrpTKCaFA4l9eJ52+di5LgR6apn0AbCjrDUqpWUqp1kqp1kFBQZU3UyFEpRtUfxCvd3ydPR4eTPZwwQ9P4HfyGSKfao9Pzy5kfvQR+T///Lc2Op1GlxHR6HQaq+ccwFWB4BUV7M1r/Zuw7XgOb/10uLKWI4QQVeZKKTJf1rauc36Hq5SyACOrbjpCiEutV91e5JTk8Pofr/NVj6cZknQY/e5PqeHtoiS4JilPPIr7YA9MvkbQdBDaAu8er9F5aAN+nh3L9h9O0KZ3RLnHvaN5KNuOZzNrQzz+niZGd6orReuFEFesK+WOWxIQ9pfXtYBTl2kuQojLZGjDodwUehPT4r7hWNep8Ng+tFufotZ9rUCvJ2kNuHwiwTcMdi+EWZ2pF5ZO/bbV2b7qOKnxeRUa97ne0dzepAav/3CIRxbuokiK1gshrlBXSnDbBtTTNC1C0zQTMARYdpnnJIS4xDRN4783/RdPoyeTN07G5hUEtzyDcdSX1PzfB5SkWEg7Wg+GfgUjVoCtCD7tSqdGu/DydWPFh3tYt+AwiYeyy/XVqZtBz4dDWzDltob8sC+F/h/9xvHMoipcqRBCVMzl2FW6EOgMBAJpwAtKqdmapvUC3qV0J+kcpdQrlTWm7CoV4uqyIWkD434Zx33R9/HkDU+euZ7+9ttkffIpNd96E58+faAwA5aMhIT1ZEWOZVvREE4cyMVhc+HuaSSieSC1YwIwe5tKC9a7G0oL2JsN5zx4d+PRDMYv3IXTpXhvSHNurh9MvrW0aH2OxU5+sZ0moT4EepV9zpwQQlysa+4A3vKS4CbE1eeVra+w6PAiZnabSfua7QFQDgcnRoyg+MBBIr5ejFtkJLicsP4NWP8m1GiGfdhKTh6xELczg+P7MrEXn73x3Oim5+ahDc5ZtD4x28LoL3dwICUfTYN//jXp7Wbg0a71GN6+Dkb9lfLFhRDiWlHh4KZpWsvzdayU2nmRc7skJLgJcfUpdhQzZMUQ8m35LOm7BD93PwDsaekk9OuHzmwmbOYM3KKiShscXA5fDYO2Y+C2NwBw2J1knyqixOLAZnVQYnVgL3YStyudlGN55y1ab7U5mbM5gRK7E18PE36eRnw9TLjpdczcEM/6IxlEBXvxQp9oOtaTnetCiMpzMcHt1/P0q5RSt17s5C4FCW5CXJ0OZx/m7pV3o9N0BHsEn/mpl6LR9p1fMNhd+L7xMjW69CrdCfrDZPh9BgxbAlFdz9nvxRatV0rxy8F0XlpxgJPZFnrEVOf5PjGE+porY9lCiOucfFUqwU2Iq9YfKX+wIWkD6ZZ00q3ppX9a0vHKLmbyN07CM+CrHh6c6B7DjSGteWjLfPTWHBj7G3gGnrfviy1aX2x3MntTAh+uPUZwNTeWj+9ANfcLD4BCCFGWSglumqY1BqKBM3VhlFJzK2WGVUyCmxDXFqUUGdYM4lJi4T/v4vvHEXa2C+Stjjl0qXkjr/62DII64Gj1BOj0eLRtc86z2f4sWu+wu7jz8RYE165W7vlsP57N4Flb6doomBnDWsk5cEKIi3LRwU3TtBco3QkaDawCbgM2/VuN0CuFBDchrl3K5SLjnXfJ+uQTbH5eOCyFeJT8/T3m5s2p/vQUzM2aldlHQXYxS9/agcGk565nbsDopi/3PD7ZEM8rqw7y7O2NGNWxbkWWIoQQQOXUKh0IdAFSlVL3A80A2QsvhLjsNJ2O4EkTqfn2NALadsDa7Ubmd9axvI8bQd0LCXnqEWxJSRwfPITkJ5/CnpJyVh/e/u50GRFNbrqFzUuOVWgeozpG0D26Oq//cIgdJ/5ZjlkIISrHhQY3q1LKBTg0TasGpAPyT0ohxBXD5/bbqfXuO3SY9hkdJr/NwiYwrqk3lMwncs6rBIweTcFPPxF3Wy8yPvgQ5fz7MSG1GvjRvGs4sRuSSdibWe7xNU3jrUHNqOlrZtz8XWQVlvx7IyGEKKcLDW7bNU3zBT4BdgA7gT+qbFZCCHERekb05L1b3yfO5MYDxlysC/sQ7LWMuv97GK+bO5E5fTqZ06ef1e7GvnUJqOXFr18exJJvK/e4PmYjH93TkmyLjce+2o3Tde1v/hJCXFrl3lWqaVodoJpSam9VTKgqyDNuQlyftqZsZfTq0fSu1oBXEuMg6xh4VefUvkjy/jhO2ON98Gpat7RovckDou8kKwu+fm07tRr4cfu4phXaaLDg95M88+0+xnaO5KkeDWSzghCiXM73jJvhAjvoVNY1pdSGi52cEEJUlRtr3MhDTR9ixp4ZdLz9DXq6TPD7TEJyV1N8KJBT078jokcGRo/TdU03v0/AXXNp3z+SjV8dJXZDMo1vrlXuce9uE8aexFw+XhdHUo6VNwY0wcN0QX/dCiHEeV3ortLlf3npDrQBdsgBvEKIK53D5WD4j8NJyEtgSZ8l1PCqAfZiSuKOcnzoCNzqR1F7xrtoGbHw3RiwFaFuf5cVGxtw6kgunYc1JKJZICb38gUvpRQfrYtj2s+HaVDdm5n3tqJ2QPnOiRNCXJ8q/QBeTdPCgDeVUndf7OQuBQluQlzfEvMTGbh8INEB0Xza/VP0utLjPvJWrOTUE0/g/8ADVH/qSchPKS1af2IzRTGjWbrnTvIzi9EbdIRF+xPVMog6TQNx87jwQ3bXH8lgwsJdKKV4/+4WdG4QXFXLFEJcI6oiuGnAXqVUk4ud3KUgwU0I8f2x73l287M82vJRRjUZdeZ6yn/+Q+7CRdSa/iHeXbqA0wFrX4bN7+Kq3pTUdnOIO6KI35VBYU4JOr2Gl58bJrMBN7MBk9mAyd1ARPNAIluUHcpOZlkYPW8Hh1Lz6dciFBTkWGzkWOzkWGy4G/Q82rUetzUOkefhhBCVcgDvB8Cfb9QBzYHjSqlhlTbLKiTBTQihlOLJDU/yy4lfmNdrHjGBMQC4bDZO3D0UW2Iited9iXv9+qUNDv8IS0ZBSGMYsRKFjrQT+STszqQguxhbcWnhepvViaXAhjXfRotu4dx4nqL1z363n59iU/ExG/HzNOLnYcLXw8TRtAIOpRbQPjKAF/vGUL+696X8aIQQV5jKCG7D//LSQWlo21xJ86tyEtyEEAB5JXkMXD4QvaanT2QfgsxBVPeoTnCOC93Dz4G1mND/vY3XzTeXNti7GJY+CLc+C52ePGe/TqeLTYuPsn99MuEx/nR7oHxF6x1OFwv/OMm0n49QWOLg3htr83jX+viU4ytZIcS1Q4rMS3ATQpy2K30XUzZMIaUoBcX///3nn694egmEpTnZM7g5zkG3EekXRZvNn2I4+D2M/BlCW523778Wrb/94ab4hZRvM0JOkY1pPx9mwR8nCfA0seihdkQFe1VonUKIq1eFg5umafuAc75BKdX04qdX9SS4CSH+yeFykGnNJN2SToYlg5SiFE6mHyX6o9U02JvDmuYas7vruDH0Rt45sBWz3gSjN4Db+YPUn0XrnXYX3Uc1pnbjgHLPbX9yHvfN+YNALxPfjbtJjhIR4jpzMcGt9un/Oe70n1+e/vMewKKUeqnSZlmFJLgJIS6UcrnIeO99smbOpCAmnFUBSdQrqUb7pFSUCsJpd8ejTRuCJz6OMTS0zD4KsotZ9fFectMsDJ7aBt/qHuWex4YjGQz/7A/6tQjl7UHNZNOCENeRCheZV0qdUEqdAG5SSj2llNp3+mcK0KMqJiuEEJeTptMR/Phj1HzzDaodTWXwBhf19uZy3OGJUpl4NAylYM0a4nrdTvq77+IqKjqrD2//0q9K9QYdq+fE4nS6yj2PTvWDmHBrPZbuTOarbYmVsTQhxDXgQmuVemqa1uHPF5qmtQfkJEkhxDXLp29f6m/dQoPduyhePpMnH3Rn4n3eGOr/TuTiOXh37UrWjJkc69mT3CVLUa6/hzMvP3c639OQ9BMFbF95vEJzmNClHh2iAnl+WSyxp/IqYVVCiKvdhQa3kcB0TdOOa5p2HPgIeKDKZiWEEFcAnYcHOnd3OtXqxMddPybVaGK4vzup3/YhtLODOh+/jrFmTVKmTiX50Uf556MnUa2CaXhjCDt+OE5KXPmDl16n8d6Q5vh7mHh4/k7yi+2VtTQhxFXqgoKbUmqHUqoZ0BRoppRqrpTaWbVTE0KIK8cNITcwu+dnFJirMbFWGLbdCzCvv486vawEDetFweo1ZH8yExwl4LSDywVK0XFwfbwD3FnzWSw2q6Pc4wZ4ufHh0BYk5Vh58us9Z4VDIcT15d82JwxTSs3TNG1iWb9XSv2vymZWiWRzghCisqxLXMf4teMZUX8wkxxm2DYblZdM8mY/CpLdqX1rFh5BttI312gGA+aQkhvIt2/vpMGNIXQZHl2hcT/ZEM8rqw5yZ/OavNa/KWaTvhJXJYS4klR4cwL//xyb9zl+hBDiutI5rDODGwzm8yNfsSWyPTy6B23IPGpMeQRjoA/JO8Jx3DAJOj0FuYkwqzM1Sn6l1W11OLQllWM70is07qiOEUzqVp/v95xiwMe/kZhtqeSVCSGuBnIArxBClJPVYWXwisEU2YpY0ncJvu6+ABQfPMjxwUPwuOEGwmbNRCtMga9HQNI2nK3HsHTfANJPFBJStxqRLYOp2yKIagHmco3966F0Hl20C51O44O7W9CxXlAVrFAIcTlVRsmrN4H/AlbgR6AZ8JhSal5lTrSqSHATQlS2g1kHGbpqKDfXupl3Or9z5py1nMWLSX3+BQInjCfo4YfBYYM1L8DWj7BW70BsyCvEHbCRmVgIQHBtb8JjAjB7GzG5/1m0Xo+nr9s5Ky8czyxizLwdHEkr4IkeDbi5fhA5RaUF63MtNvKLHdwUFUjzMN9L9nkIISpPZQS33Uqp5pqm9QPuBB4Hfj29YeGKJ8FNCFEVPt//OW/veJsX273IgPoDgNJi9qcmTyZ/+QrC58zGs1270jcf+B6+fwSMZhizmTyrF3G70onbmUH68fwy+z9f0XqLzcFT3+xlxd6Uc85vQMtaTL6tAcHe7he/WCHEJVMZwS1WKRWjadonwBKl1I+apu2R4CaEuJ65lIuHVj/E3oy9zOw2k/p+9fE0euIqKiLhrsE4UlKoOW0a3rfeUtogZS982gWiusKQBXD6Lp3T4cJW7MBmdWKzOrBZHRzdkU7shtKi9d1HxuBWRsF5pRTrj2RQbHfh52HEz9OEn4cJk17HjA1xzN6YgMmg49Eu9Rjevg4mw4WeACWEuJwqI7i9TumdNivQBvAFViil2lbmRKuKBDchRFVJK0pjwPIB5JWUntPmafQk2COYujYfBs2Ow+9kDtaHBlHzwbGEeIagbf0IfnoGer8Lre8/b98XW7Q+IbOIl1ccYO2hdOoGefLWwKa0qu1f4bUKIS6Niw5upzvxA/KVUk5N0zwBb6VUaiXOs8pIcBNCVKVThafYmb6TdEv6mZ80SxppWYkMXZJJu0OKtU015vf2ok2tdrycGI930nYYvRECo87f91+K1ncbGUOdJoHlnt/aQ2m8sCyWfKuDFeM7EOZf/tqpQohLpzLuuHkAE4FwpdRDmqbVAxoopVZU7lSrhgQ3IcTlkmXJJOndtzHN/Y6MBsG82D2PeuZQXtp/EHeCccSMAr0B34ED0Xt5ldlHQXYxP8zYR0ZiAbeNbkLd5uXfSXoiq4je72+ibpAni8e0w80g58AJcaWqjOD2FbADuE8p1VjTNDOwRSnVvHKnWjUkuAkhLre85StImToVZbOV+Xt9YCBBj07At39/NP3Zocpuc7L0rR0UZpcw5Pk2ePq4lXsOP+5PZcy8HdzXrjYv3dG43O2FEJfGxRzA+6dIpdSbgB1AKWUFzt7mJIQQokw+fXpTZ9FCgh5/nJLJDzLtHg9ef9ADz7syqPP+s5jCw0l97nkSBgykaOvWs9obTXq6PRCD3eZk7dyDFSp91bNxCKM6RDB3ywmW7zlVGcsSQlxiFxrcbKfvsikATdMigZIqm5UQQlyD3KOjCRz9EM3vn8jEsXOJr2lmREQNkmNfpvbjXQh96zVc+fmcHHE/iY88gquo6G/t/Wt4ctOAKE7GZrNvXXKF5jD5toa0qu3HlCV7OZZeWBnLEkJcQv8a3LTSUyVnUHrwbpimafOBX4Cnqnhu55tTuKZpyzRNm6Np2pTLNQ8hhKiomMAYPuv5OZh9ud/PRNqPT1At9lHqTmpD0JgRFK79lZQXXjzrzlrjm0Op3TiA35YeI/tUUdmdn4dRr+PDoS1wM+p5eP4OLLbyF74XQlw+F/qM2w6gO3AjpV+RblVKZVZoQE2bA/QG0pVSjf9yvSfwHqAHPlVKvX6ePrpS+vXtTE3T5iql7jvfmPKMmxDiSpWQl8DgFYNp7BXOJyWe6A8uBxSZpxqTsT6TkH718GtbCzQdmLzgxjFY9DVZ9PLvePi4MWhya/TG8p/PtvFoBvfN+YMe0SG8O6Q57kbZrCDElaIynnHbCtRVSq1USq2oaGg77XOg5z8mqAemA7cB0cDdmqZFa5rWRNO0Ff/4CQZ2AUM0TVsL/HoRcxFCiMsqwieCp9s8zbbcw3wRfTM8tg86PE5A42I8wzTSlh3F+sc6OLYGts+BmZ3wOLWGW+5tRFZSIb8vi6/QuB3rBTG1VyN+jE1l4IzfSMqRovVCXA0u9I7bAaA+cAIoovSum1JKNa3QoJpWh9IDfBufft0OeFEp1eP066cpHeC1c7R/AvhDKbVB07RvlFIDzzee3HETQlzJlFJMWj+JX0/+yrzb5xETEAOAIyeHhDv7oZlMRCxdgt6eWVq0PmU3tB/PuvQGlmARAAAgAElEQVShxG5OpXnXcKJaBRNc2/tMzdQL9cvBNB5btBuDXuPDoS25Kar858QJISpXZRwHUrus60qpExWcUB3+HtwGAj2VUqNOv74XaKuUeuQc7RsDLwKZQKFS6oky3vMQ8BBAeHh4qxMnKjRVIYS4JPJK8hiwbABmg5mven+Fh7H0kFzLzl2cuO8+vG/pTOj776M5SkorL2yfjT20E6uLn+P4wSKUS+Ht707dFkFEtgwmoKYnRjc9Whl1Tv8pPqOQ0V/uIC6jkMk9G/JQp7pnAqBSCovNiaaBh8lQpZ+BEKJUpVROqExlBLdBQI9/BLc2SqnxlTGe3HETQlwN/kj5g1E/j2JA/QG80O6FM9ezPvuc9DfeoPrTU/AfPrz04t6vYfmjYHSneMDXJKTVJG5XOokHs3E5Tv+9roHJ3YDJrMfkbqBu8yBu6B1RZtH6whIHT32zh1X7UmkY4o1SkGOxkWuxY3O6MBl0PNSxLg/fEikBTogqdr7gdqX8vy8JCPvL61qAHDIkhLiutKnRhvsb38+c/XPoENqBLuFdAPAfMRzL9u2kvTUNY61aeHfpAk0HQY1m8GU/3FeOotHojTRqX4MSq4OTsVkUZpecLlxf+lOYW8L2VcdJP5FfZtF6LzcD04e2ZPamBH4+kIav2UjzMF98PY34eZg4cCqfD389xpKdSTzTqxG9m9Yo99eyQoiLd6XccTMAR4AuQDKwDRiqlIqtjPHkjpsQ4mphd9oZ9sMwTuafpHX11gR7BBPsEUyIy5u6L36J4cgJgiZOJGDUyNLgdHwzfH47tBgGd3x43r5jNyazYeERvAMrVrR+2/FsXvg+lgMp+bSN8OfFvjE0qlHtYpYrhCjDFfVVqaZpC4HOQCCQBryglJqtaVov4F1KjwOZo5R6pbLGlOAmhLiaJOYnMm37NJIKk8iwZJBTkgOAya54eKWL9gcVu1v7c2BkRyKDGnJn8hF8t0yHwfOgUZ/z9n3qaC4/zjpdtP6BGOo0Ld9mBKdLsWjbSab9dJiCYgdzR7ahfaRsaBCiMl1Rwe1ykOAmhLia2Zw20i3ppBalkpAXj+GzpTT8bg/Hwk281s9JYEgEs9JzCclNRD20CafLjN7Xt8yap1BatH7Vx3vJTCqkw8B6NOsSVub7zienyMbAGb+RZ3WwakIHgqu5X+wyhRCnSXCT4CaEuMbkrVxJyjNTcfp6s9Mvl8BCjYjsEpRVBwrc6kURPGUKXjfdVGZ7u83J6tmxJOzNpN/EltSs51vuORxJK+CODzfTpJYPC0a1xaAv/0HAQoizVcYBvEIIIa4gPrffTu0v52L28adVcQgWE2yJckOLKSJ4UHtc1mISR44iccxYSuITzmpvNOnpen801QLcWfPZAUqs5S99Vb+6N6/0a8wfCdlM+/lIZSxLCPEvJLgJIcRVyty0KXWXfU/0j6tpvuBbvhwYyKg+/qR4/UDd6U8T/OQTWLZtI75vX1JffRVnXt7f2pvcDXR7IIbC3BI2LqpY8OrfshZ3twlnxvo4fjmYVhnLEkKchwQ3IYS4BkT6RvLFbV/g5RHMyGB/9iwdTIBrAZHvjsO3353kzJvPifvvx1VS8rd2IXV9aH1bbQ7/nsrR7RULXi/0iSamZjUmLt5DYraUzhKiKklwE0KIa0SYdxhzb59HYLUwngiPJLc4G8Mvj1HD5ytqje5MyYGDpE19HBK3QdIOOLULrLm07lWH6hHVWL/gMAXZxeUe192o56N7WuJSinELdlJsd1bB6oQQIMFNCCGuKcEewbzV+W2yXSW81LgzaujXENIE75x5BDQsIHfFr+Q91wc+vRVmdYb3m6OL/4Wu90fjdCp++eIAylX+TWu1AzyZNqgZe5PyuGvmFpJzrZW/OCGEBDchhLjWRAdEM6HFBFafXMN3WhEMWwITdhH05heYoyNJ2V2dko7vw11zoVoozB+I77636TgokuTDufyxMgGnw1XucXvEhDDr3lbEZxTR54NN/BaXWQWrE+L6JseBCCHENcilXDz080PszdzL132+pna12gDY09JI6NcfQ4A/db76Cp0B+OFJ2DUPVbsjP1lfJG5vPiazgTpNA4hsEUx4tD8GU9lnwpUl7nTR+oTMIp6+rSEjO0RIeSwhykHOcZPgJoS4DqUWpTJg2QDCvcOZ22suRl1pfdLCzZtJHPUgPn37UuP110pD1a75sHISLjdfTracRVxyEAm7MyixODC66Qmt74u7twk3dwNGsx43swFPXzciWwafs2j9E4v38GNsKn2a1aRjvUByimzkWOzkWmzkF9vpWC+Iu1qHoS+jvRDXMwluEtyEENep1SdWM3HdRB5s8iATWk44cz3jgw/JnD6dkP/8B7/Bd5VeTIuFxcMhLwlGb8DpH8Wpw7kc25VOalweNquDEqsDe/H/bz4Ijwmg+8jos4rWAyil+GhdHNN+Psyf/6kx6jV8PUyY9DqSc600Dq3Gi31iaF3Hv0o/ByGuJhLcJLgJIa5jL/z2At8e/ZZn2j5DPb96BHsEE+QWQPrYCRRt3lxatP7BUaV33gpS4aN24BsGI9eAwXRWfy6Xwl7s4Oj2dDYuOkK1IDO9xjY5Z9H61Lxi7E4Xvh5GvNwMaJqGUorle1N4deVBUvOL6dcilCm3NaS6lM4SQoKbBDchxPXMYrcwdOVQ4vLi/nY9UFeNsSudNNmdR3qnaFxPjSYyuCGhSbvRL74XOkyEri+ct++/Fa0fGUOdJuUrOG+xOfjo1zhmbYjHoNd4pV9j+rWoVe41CnEtkeAmwU0IcZ2zOW2czD9JuiWdNEsaGdYM0i3pJOafJOq73fReW8ChUJg2QI9PSDgztBqE71kCI1ZCnbLrnf7pr0Xrb7yjLi171C73ZoQTWUU8+c1edp3MYfHodrQI97uY5QpxVZPgJsFNCCHOK23Ft2RNfRG7jwczu7pwc2qMOVWIX74Le81uaCYzAQ+Owi0qqsz2dpuTX+ce5Oj2dDoMqkezLmHlnkOuxUbvDzahFKwY3wE/z7O/phXieiDBTYKbEEL8K+u+/SSNG4cjPf3MNaVTmHzccdoMuIqL8Rs8mMDxj2DwO/uOmFKKVR/tJfFgDoOebk1AqFe557A3KZeBH2+hfVQAc4bfUOaOVSGudecLbnIArxBCCADMTRoT8f13hM2aice8j3numTAemOxOzh2niHzvEfwG30XOokXE9ehJ1uefo2y2v7XXNI1b7m2Eyaxn9ZxYHBUofdW0li/P9W7EusMZfLw+7t8bCHGdkeAmhBDiDIOfH16dOlG7dWc+GjiPEJ/ajAmpzuatzxHSMpe6n7+LuUkT0l9/g/i+d2BP+3theo9qJm69rxFZyUVs/T6+QnMYdmNt+jaryds/H5bqC0L8gwQ3IYQQZQr2COaznp9Tz68+jwX5cWD/ItxWDSSsUwa1nhuFPS2N5ImTUHb739rVaRJI406h7FmTSOKh7HKPq2kar/VvQkSgJxMW7iY9v/yF74W4VskzbkIIIc4rtziXAcsH4KF3Y7F/J8w7voCCU+SlhnBqnY6AVm4Ed/QCTQcmL7j5Key1OrL4lW3YS5wMea4N7p5nH9D7b46kFXDHh5uJDPZk1r2tqelrroLVCXHlkWfchBBCVJivuy+vdniVEwVJTHOzw2N7YeBn+HTriG/rILJ2lFCQWg28QkqrLnzZD+OWt+l2fyOs+TbWzT9MRW4S1K/uzfR7WpBwumj91visKlidEFcXCW5CCCH+VdsabRkRM4LFRxbza/ImaNwfBnxK9dmrcY+O5tSqLGw3vwNjf4PGA+HXVwjeeD9telYnbmc6y9/fzYFNp7AW2v59sL+4tWF1vn/kJnw8jNzz6e98tjmhQiFQiGuFfFUqhBDigticNoatGkZqUSpL+i4hyCOo9HpiIgn9B2CqU4fa8+ehMxphx+fww2Rc5kC215jJ4YN68jOL0XQaNev5EtkiiIBQL0xmPSZ3AyazAZO7Hp2+7PsJBcV2Ji7ew+oDafRrEcqr/Zpg1GvkWu1nitebjXqa1PK5hJ+IEFVDznGT4CaEEJUiPjeewSsG07J6Sz7u+jE6rTRo5a9eTfL4CfgNG0bIs1NL33xqN3xdWrReDZpLplcn4namE78rg5xUS5n912kaSNcRjcosWu9yKab/eoz/rTmCUa/D5nCd9Z6ujYJ59vZo6gSWXTdViKuBBDcJbkIIUWkWH17My1tf5qkbnuLe6HvPXE977XWyv/iCoEcnEDBmTGnZK2sufHknZCfAw1ugWk0ActMsFGQXYyt2YLM6sFmdFOYUs3dt0r8Wrd90NJO1h9LxMRvx8zTi62HCz8NI7Kl8PvjlKHan4sFOETzcOQpPN8Ml+UyEqEwS3CS4CSFEpVFKMWHtBNYnrSfYI5jqHtVL/zQF0v7zHQRtPIi+5y1EvDYNo9kDMo/BzI4Q1gaGfQu6cz9efbFF69Pzi3n9x0Ms3ZlMSDV3nrm9EX2b1bzYJQtxSUlwk+AmhBCVKq8kjwUHF5BUmES6Jf3MT6GtgH6/Ke7e4OJoqI5vHoiiRlhDHtQFErXmv9DjVWg37rx9/7Vofbs7I2nRPbzcRet3nMjmhWWx7E/O562BTRnUuvy1U4W4XCS4SXATQohLotBWSEJeAmmrvifk7UVYPA28PdiNpOoGZjgDaXRwC47b5uBQvrg3jimz5imUFq1fO/cgx7anE92xJrfc07Dcc3E4Xdw7+w92Jebw3bibaBhS7WKXJ8QlIcFNgpsQQlxy1thYkh4ehyMvj0wPBz55Dox/KV+q8/IicOxY/O4dhs5kOqu9UootS+PYtfok3UZGU/+GkHLPIb2gmN7vb8LTzcCyR27C2738BwELcanJAbxCCCEuOXNMDHUWL8anR3dqtu3Mlg7+fNnVQO4thYSNaYdHq1akv/UW8b37kL969Vnns2maxo131iWkrg/rFxyhILv8pa+Cvd354O4WnMy2MGXJPjkDTlz1JLgJIYSoMsbqwdR84w0i3/mAwe+tJL5nDA/f6McG+w+E3d+MsBkfonMzkTx+AifvG05JXNzf2uv0OrreH41yKdZ8dgCXq/zBq23dAJ7o3oCV+1L44rfjlbQyIS4PCW5CCCEuCV93Xz7t/inNgpszJSiQVRtfwmvrA0SMa0bIU+MpOXqUkw+MxJH998L0PkFmOg6uz6mjuexefbJCY4/uVJeujYJ5ZdVBdp3MqYzlCHFZyDNuQgghLqliRzGjV4/mUFYsXxsiCT+8GlAUV+vM8dlH8WhUi7AnBqDpDaDTQ43mqJAm/DRrPwl7Mxk4uTVB4d7lHjfPYuf2DzbicimWPnwTIT7ulb84ISqBPOMmhBDiiuFucOeNTm+g15t42tuAfcJOuOkx3G27qd48i6J9J8ia9iKseAyWjYdZndE2v0fnoQ0wexlZPScWu835r+P8k4+HkY/uaUmu1U7vDzax7Xj2vzcS4gojwU0IIcQlF+IZwgvtXmBv5l5mHl8BXV+AJ47gO3M/1W7rRkasL0UdF8CE3dCoN6x5Affl99Hl7jByUi2snXuQnNSico/btJYv3427CW93A3fP2soXvx2XDQviqiJflQohhLhsnt30LMvjlzOnxxxaVW8FgKuoiIS7BuPMyyNi6RKMQUHw+0z4+VmoVoPfA2ewfVMJAP41PYlsGUxkyyD8a3he8EG9eVY7E7/azS+H0unfsrRovbtRX2XrFKI8rupz3DRNqwtMBXyUUgNPX/MEPgJswDql1Pzz9SHBTQghrkxF9iIGLhuIUzn5pu83VDOVHpJbcuwYCYPuwty4MeGfzUEzGCBpOyweDkXpFHT6H/HOzsTtTCclLg8UePq6YfY2YnI3YDIbMJn1ePm507J7+DmL1r/3y1He++Uo0TWqcUMdP3IsdnIsNnItdvKL7XSqF8TEbvXx8zz7nDkhqsplC26aps0BegPpSqnGf7neE3gP0AOfKqVev4C+vvlLcLsXyFVKLdc07Sul1ODztZXgJoQQV649GXsY/sNwetTpwRud3jhzPe/77zk1eQr+w4cTPGVy6d00SzYsGQVxa2H4cojoSFFeCQm7M0iJz8NmdWKzOiixlhavL8wpwedfitb/cjCNyUv2UuJw4edhws+ztGi9Qafj18PpeLsbmNS9AUPbhKPXla/0lhAVcTmDWyegEJj7Z3DTNE0PHAG6AUnANuBuSkPca//o4gGlVPrpdn8Nbk8DPyildmuatkApNfR885DgJoQQV7YZe2Ywffd0BtYfSJRvFMEewQR7BOP94VeUfPUt1Xr1osarr6BzdwdbEczoCI4SGLsJzGWXzYKLL1p/KDWf/yw7wJb4LBrVqMaLfaJpWzfgYpcrxHld1q9KNU2rA6z4S3BrB7yolOpx+vXTAEqpf4a2f/bzzztuOUqpFZqmLVJKDSnj/Q8BDwGEh4e3OnHiROUtSgghRKVyupw8sf4J1iWtw+Fy/P8vlKL/7xpDfnWQUceXo1MGEB7RjGZOjeB5gyH6DhgwG87zbFt+lpUfZuyrcNF6pRQ/7E/llZUHSc61Mu6WSJ7sUf7aqUJcqCstuA0EeiqlRp1+fS/QVin1yDnaBwCvUHqH7lOl1Gunn3H7ECgGNskzbkIIcW1wKRe5JbmkW9JJt6STZkkjsSARtW4rXT7fT4G74s2BetJqefBBYAfabpkN/WZBs/M+MfO3ovX1WgfTZXg0emP5Dlaw2pw8//1+vt6RxMf3tOS2JjUuZqlCnNP5gpvhUk8GKOufOedMj0qpLGDMP64VAfdX8ryEEEJcZjpNh7+7P/7u/jT0/8tdrVZQfNsBTo59mDcW5rL6ZjfWFq7GmFeXwPXPYnefg2YyEzh2DN49epx1R81o0tN9ZAyBtbzY+l08Hj5udBhUr1xzM5v0vNKvCccyCnnym700rFGNiMCyn5sToqpcjnPckoCwv7yuBZy6DPMQQghxFXGPjibi68WYGzSg+0+Z9P3NgeVEMVlOHW6GDHC5SH7scU4Muxfrvv1ntdc0jVY969Ckcy32/JJI4oHyH8BrMuj4cGhLDHqNsfN2UGwv/0HAQlyMyxHctgH1NE2L0DTNBAwBll2GeQghhLjKGIODqbNwIfU2bqD2zq3MfvlGho808VvnNCImtifkpf9gO36c44MGcWryFOxpaWf10b5/JH4hHvzyxQGKC+3lnkOor5l3BzfncFoBz39/dkAUoipVaXDTNG0hsAVooGlakqZpI5VSDuAR4CfgILBYKRVblfMQQghx7dB0OgxBQXiZffi468d0DO3Ey4H+fL77Q/zyPyHyf2MIGPkA+atWEX9bL4oPHPhbe4NJT7cHYrAW2lk3/1CFKid0bhDMI7dEsXh7Eou3J1bW0oT4V1f8AbyVQTYnCCHEtcvusvPM+sn8eHI1HxbpuDn9OHjXwFZ7ECfeX4fmZibim8Xoq/n8bffpzp9OsOXbOG69rxGN2pd/o4HTpbh39u/sOJHDtw/fRHTNapW4KnE9kyLzQgghrllGnZFXOr1OA78GPO/vQ+bA2RAcjWn/+4Q2OYQ96SQpA5qjXvSFF33h1Vqw9WOadw0jtL4vG786Ql6Gpdzj6nUa7w1pgY/ZyPDP/mC7FK0Xl4AENyGEEFc9k97EG53eoMhh4dnUNahhS2DcNjyGPktw/zYUJJnJcfWFjpMg7Ab4cQq6b4bT5e4wNJ3Gms8O4HK6yj1ukLcb80a1xcOk5+5PtvLlFilaL6qWBDchhBDXhEjfSJ5s/SSbkzez4NACCKoPNz2K/3+/wKtLF9K+24M1sC8MWwrdXoJDK/H+ujude5lJjc/ni2d+Y8PCwyQdzilXiKtf3Ztl4zrQISqQ576P5alv9spuU1Fl5Bk3IYQQ1wylFOPXjmfLqS0s7L2Q+n71AXDm5ZHQfwBKuai7dCl6X1848Rt88wBYc4iP/oAjGY04sT8Lh92F2dtIRLMg/Gt6YnI34Ha6aL3JbMC/picGo/6ssV0uxbtrjvD+2mM0reXDq/2a4FKK7KLSovU5FhseJj13tgjFzXB2eyH+dFkrJ1wJJLgJIcT1I8uaxYBlA/Bz92NR70W46d0AsO7bz4mhQ/Fs355aH3+EptNBYQYsGQkJ66HHq9hbjuHE/izid6VzfF8W9pKz75z5Vvc4b9H6n2JTmbR4D4UljjJ/XzvAg+d7R9OlUfXKW7S4pkhwk+AmhBDXlU3Jmxi7ZiyDGwzmkeaP4OPmg6ZpZC9YQNpLL1Ot123UePXV0qL1Lid8dS8cWw0ProWQJgC4nC5sViclVgc2qwNbsYPC7GI2Lzn2r0XrE7Mt/J6QjY/ZiJ+HEV8PE/6eJvYl5/Gf5bHEZxRxS4MgnusdTd0gr0v50YirgAQ3CW5CCHHdef2P15l/sLSUtZvejSBzEMHmILpsKqT1twex1QvHc9pL1IlsibE4Hz5uB2Y/eGgdGM3n7Pdii9bbHC7mbjnOu2uOUuJwMqpjXZ7o3gC97sL7ENc2CW4S3IQQ4rrjcDnYkLSB5MLkM0Xr0y3ppBSlUHNnEuOXOSlyh2mDjFC/Lo/XvIWbVz3P/7V33+FRVfkfx98nM+mBNBIIoQRCk95EiqAgKHYUEFnUpQn2hiIK+8Mu6K51BUUFYS2IgC4WVFBXBRHpXTQQSghpJIH0MnN+fyTrIgQ0kGQS+LyeJw+ZO3PuPSeXGz7ccr50Gw+XPXPSdf+uaP25del7Yyu8fcp331pKVj7Tl+5k0foE7uzXjAkXtzyd4coZRMFNwU1ERI6SX5xP/LpvKL7/MczhbOZfF8lXddN41NWMnhu/p7jDXRQ76xJ43nn4t29f5jqstaz/Yi8//ns30c1DuOqeTnidwlmziQs3sWBtAnNGnUvflpGnOzQ5Ayi4KbiJiEgZilNTSbjjTvI2bTrhZ2pfeSWR992Ld1TZ1RV2/JDI1/N+pvugpnQZGFPuPuQXuRj0ykqSjuTz6V29iQ458WVaOTsouCm4iYjICbgLCsh49z2Kigp4P/1LVhbt5Gp3DsOiu5Ke1ZP0OW+Blxfho0cTPnYMXgEBv2tvreXLN7exe30qgx/sQmTj8pe+ik/L4cqXV9AsMogF43vg49Q0q2czlbwSERE5AS9fX8JHjaTeuPHcNnE+MX0uY1pMEDNyVhMR8ytN3/4ntfr1JW3GDHYNvJTs77//XXtjDBcMb0lAsA/LZm+nqLD8k+82qRPIM0Pas3F/Jk8v3VFRQ5MzkIKbiIhIKW8vb57u/TSDmw3m9ZBgXtv3GT6LryC6UzyNp92FIziYhLvvoWD37t+18wv05qKRrclMyeWHhXGntO3L2kUxqlcMc1bu4dPNBytiOHIGcnq6AyIiItWJw8vB1J5TKXAXMHP3Z3RvNZSOW5YQsOtrGvZoQvwiNwdGX0fMnd3x8vUG44CG3WjQbigd+zdi47J9NG4bTkz7sud4O5mHLj2HjfszeXDRZqJC/OjcKLQSRig1mc64iYiIHMMYw+TzJlM/qD6TsreQdfsqGDIb76j61L/ARUFSDklvLYMdH8PmBbD4Zlh8M90HRhLeIIiv/7WD3COF5d6uj9OLV/7SmbBAH4a9top3V++rhNFJTabgJiIiUoYgnyCe7v00STlJPLX2WWg7GEZ9RtBz26hz220c/tWLzKbPwIN7oO8U2LoIx5z+DBjkT2Gei89mbubXtckU5pdd+upE6of4s+SOXvSIrcPDH25h0qLNFBSraL2U0FOlIiIiJzFz00xmbJzBtN7TuLzp5QBYl4t9Y8aSt2EDMQvex69lS9j9bUnd08IcdraYyco1dcg7UojD24tGrcOI7RxJ4zbh+AY4MX9ivjeX2/Lcsp288s0uOjYMYeYNnYkK/t9UIdZacgtdBPg4ylW5Qao/TQei4CYiIqeo2F3MqM9HEZcZx8KrFhIdFF2yPC2N+GuuxSswkJiFC3EEBcKRgyXhbe9K3N1uIanZJOI2pLJ7fQo5h0svnRrw8XPi4+/Ax89JUKgf5w9tdsKi9Z9vTWLCgo34eTtoGhFIRm4RmbmFZOQW4XJbujYO5ZGr2tA2OriqfiRSyRTcFNxEROQ0JGQlMOTjIbQMbcmbl7yJ06vk2b7cNWvY+9eRBPXpQ/Tzz+Hl7w+uYvjiYfjpNbjmNehwPdZtSYo/QtLuwyUF60uL1hfmuUiMy8RdfPKi9XEpWTz2yQ4Ki12EBfoQEuBDaIA3Ti8v3v5xL+m5hQzv1oj7L25JWKBPVf5opBIouCm4iYjIafp418c8vOJhOkR0oElwEyIDIon0j6TxVz8T/M/38W19Dg1nzMC7bl1wu+CtKyBpC9y6AkJjTrje0y1afziviBeX/8rcVXsI9HEw4eKWjDivEU6HbmOvqRTcFNxEROQ0WWt5dfOrfLf/O1JyU0jLT8Nt3QB0/tXN3UvcFPk6WHb7udRu34ketWM594NbILI1jPwUHCeegasiitb/mpzFIx9vY2XcIQa0rstrN3Q5pdqp4nkKbgpuIiJSwYrdxRzKO0RKbgr7s/aTtOUn2k7/N75ZBcy4wsGqVobJDQYy7PvXoO8U3D3uBper5HJqGY4uWh/RsBZX3tUB/6DyXfa01jLru908vfRnJl3ailsuiK2IoUoVU3BTcBMRkSpQfOhQSdH6DRuI6xTJ4SOptMzxJjgjH1eBF8bXl7BRI6lz8814BZb9MMKezWksnbWFxm3CufSWduV+YtRayx3vbuDzbUm8O/Y8zmsaXhFDkyqkWqUiIiJVwBkeTqO35hAydAgt97uJKazFzqAi9jR3UKebk1r9LuTQq68RN3AgmYsWY93u49YR074O3a+OJX5TGjt+KH/pK2MM0wa3o1FYAHe+t4HUrIIKGJlUFwpuIiIiFcjL15eoxx+nxYrv6fHFD8Q9fB0TrnQw69wsonrnEfPOXHzqR3Nw8mTihwwhd82a49bR8aKGRLcM5fsFv5KZnFvuPtTy82bGiM4czivi7kNo5OoAACAASURBVPkbcLnP/KtrZwsFNxERkUri8HIwtcdURrYZyfzatfhb4pf4Lb+OxmNbUv/xh3BlZLL3xpvI+uab37UzXob+I8/B4TAsm7Mdl+v4M3N/5Jyo2jwxqC0/7DrEC8t/qaghiYcpuImIiFQiYwz3dbmPW9qPZ0mtIOY3aIX54SWCt99D7JgofJs2IHHiAxSu/xIObobkbZCxh6BQPy4c0YqUPUdY99meU9r20K4Nua5rA17+Oo5vfk6p2IGJRyi4iYiIVDJjDLd1vJ3e0b35h00jbtQS6HkHXgkraHDOOsjP4sAdt2Jn9IaZPeHFDvDv22nWLoiW3eux9rM9JO0+fErbfuzqtpwTVZvxb69jwZr9FTwyqWoKbiIiIlXAGMNjvR4j0DuQBze+QEG/yXDfDnxuW0jUhDHkp/uQnHsdXDcPet4FG96GN/rTp7+ToDA/ls3eRnZG+R808PN28O7Y8+gWE8bERZt5+MMtKlpfgym4iYiIVJE6/nV4vNfj/JLxCy+ufxF8AiC2H7VHTiTsrzeR8ekKjuzzg4sfhxGLIOsgPvP6MeDCNLLTC5j78EoWP7uOjcv3kZWe/6e3Gxrow9zR3bjlgljeXb2P62f9SPKRP99eqg/N4yYiIlLFnvzxSebvnM9r/V+jZ3RPAGxhIXtvvImCuDiaLFqIT0wMHE6AD0ZCwhoyW99LXMANxG1M51BCNgCRjWsRVj8QH39naeF6J77+Thq0CqV2nbIn+v1080EeWLiJAB8nEy9pictaMnILycwtIiOnkAAfB+MviKV+SNntpfJpAl4FNxERqUbyi/O5/pPrOVx4mEVXLSLMLwyAosRE4q+5FmdUFDHvvoNXQAAUF8LyqfDjDOg2Di57lsyUXHZvSCV+UyrZGQUlResLXFD6T7qPv5OLx7ShcduyJ9/dmZTF+H+tZc+h/0014uv0IizQh0M5hTiM4fa+sYzt3RQ/7/KV3pLTp+Cm4CYiItXMzvSdDP90ON2iujGyzUgi/SOJDIiEVevYf+tt+LZqWVK0vl69kgZLJ8HqmTBiITQfcNz6rNtSWOAiOz2f5W9t/8Oi9flFLuLTcgj29yY0wAf/0tqo+9NzeeqzHSzdmkTDMH/+dnlrBrSuW+4KDnLqFNwU3EREpBp6Z8c7TPtp2u+WBTgDuGB/ECPmJ2P9fEmdOoYG3foSExCF/5xLIScNbv0BgiJOuN6igtKi9etOvWj9yrg0HlmyjV9TsrmgRQQzRnQm0Nd5SuOU8qnxwc0Y0xSYDARba4eULhsEXA5EAq9Ya788UXsFNxERqa4OZB8gMTuRlNyU376ScpLI3fkzf5mzl5AcyyuXe/FTG2/uan4do5c/D836w/XvwknOgh1btP7SW9pRK8yvXH0rcrmZt2ovT366nSva1+fF6zvqzFsV8GhwM8bMBq4AUqy1bY9aPhB4EXAAb1hrp51gFUeva+F/g9tRy0KBv1trx5yonYKbiIjURPlpyey5/Tbspu2su6wpH4fs4Vp3DBft2Ehx3b64nJEE9OhByLXXYhxln1GL35zGstnbCKjtw7DJ3fD2Lf89a698E8ezX+zk8UFtubF749MdlvwBTwe3PkA2MO+/wc0Y4wB+AQYACcAaYDglIe7pY1Yx2lqbUtqurOD2D+Ada+36E/VBwU1ERGoqd2EhSVMf4fCHH/5uuZe3xSukDsWph/Bt2ZK6D00isHv3Mtdx4JcMPnp+A63Pr0/fEa3K3we3ZczcNayMO8TCW3vQvkHIKY1F/hyPXyo1xsQAnxwV3HoAj1hrLyl9/RCAtfbY0HbsehYedanUANOAZdba5Sdrp+AmIiI1mbWW3NWrsS4X76R9zpvJH3KRu5jHTCR5DSaS8o/nKUpMJOiii6j7wP0lU4kcY9WHcaz/Yh+X3tKOph1PfH/ciWTkFHLFyyswBj69szfBAd4VMDIpy8mCm6cm4I0Gjq67kVC6rEzGmHBjzKtAp/+GPOBOoD8wxBhzSxltxhlj1hpj1qamplZg10VERKqWMYbA7t0J6tWLcVc9xtjud/GJvzcTXAfwTXyOpn8fR8Q9d5O7ahW7rryK9H+9fdw6ul3ZlDoNg/jm7Z/JOVz+CgyhgT68MqIzyUfymfDBRtzu6n+P/JnIU8GtrDsbT/g3wFp7yFp7i7U29r9n5ay1L1lru5Quf7WMNrOstV2ttV0jIsr/PwsREZHqyBjDuPbjmNRtEt8EBvAYqXgtGUednBeJffRqgs7rSvLTT5Pz4+rftXM4vRgwus1vT5yeyhW3jg1DmHJ5a5bvSGHW97srakhSDp56rjcBaHjU6wZAoof6IiIiUuOMOGcEGfkZvLb5NXoPeIiBu37Eue4fRNf3JT44kgO3jabpTXVwBnmDcUDDboT1m0Kvwc34bv4vbP32AO0ubFDu7d7UozE/7Unn2S92Eh7ow9CuDf+4kVQYT51xWwM0N8Y0Mcb4ANcDSzzUFxERkRrplg630D6iPY/tXcLBa2fCbavx6j6S6Oub4S60HFiajfUOAuMFP7wEb15M2/ZFNGoTzspFcaQn5pR7m8YYpg9uT/emYTywcDN/+2grhcXuShidlKXSg5sx5j1gFdDSGJNgjBljrS0G7gC+AHYAC6y12yq7LyIiImcSp5eTaedPw2VdPLTiIVx1msNlz+B390fUe/wpcvfmkppxIYxeWjLvW0Y8ZtYF9Ot5AG9fB0te2siqj3aRui+rXJdOg3ydzB3VjXF9mvKvH/fyl9d/JEVF66tEjZiA93TpqVIRETmT/Tvu30xZOYW7O9/N2HZjf1ueOGUKhxcuouGs1wjq0wcy9sCCv8LBjRxsOZk1yf1J+OUw1m2pFe5HbOdIGrUOwy/IG19/Z2nxegdejhOf5/l4UyITF26mlp+TmTd0pkvjMAqKXWTmFpGeU0hWfjGt69cmSFUX/jSPTwfiaQpuIiJyJrPWMvG7iSzfu5x/XfYv2tYpme/enZ/PnmHXU5ycTJMPF+MdFQVF+fDFw7D2TWh6IflXz2f31gx2rU8l4ed03K7jc0FAsA/9bjznhEXrf046wrh56ziQmYev04vcQtfv3o+o5cukga24plM0Xl6qvPBHFNwU3ERE5Ax3uOAwQz4ego+XDx9c+QEB3gEAFMTHs2fwELwbNKDhqzPxrl+/pMHa2fDJvdB3MlwwseSzuUWk7MuiMK+YwjxXyZ/5xexan8qhxGx6XBNLpwFlF60/nFvEjG/jKHZZQgO8CQnwITTAB4eXYea3u9i0P5POjUJ45Ko2msD3Dyi4KbiJiMhZYE3SGsZ8MYbavrWpH1ifyIBIIgIiaBmXT9vnP8fLz4+ol14gtOt5JQ0WjYWti2HMl9CgzJwAHF+0vt+NrXCWo2i9221ZtD6B6Z/v5FBOAcO6NmTiwFaEBfqc7pDPSApuCm4iInKWWL53OSsOrCAlN4XUvFRSclNIz08nOs3y4AcuwrJg/uA6HO7Tjl6RnfnLVy9gHN4w/nvwDTrheo8tWn/Zre0ICi1f0foj+UW8/NWvzFm5h5b1arHo1p74eZe/duqZTsFNwU1ERM5iha5CErIT2LN3M/5T/0nIjgN81S+cWd0yGVq/Dw+veBd37BCKO96J8fbGr3XrE65rz+Y0vpy9DaePg2sndCakbkC5+/PVjmTGzF3L8G6NePradqcztDOSgpuCm4iICAC2sJCDjz7K4UWLyakXTEH2YUJywOuoOBB0wQVEPjgR36ZNy1xH+sEcFv99HcF1/Ll2YhccJ3nq9ESmf/4zM/+zi+eu68C1ncs/EfCZrDrWKhUREREPMD4+RD3xBHX/NoXI5u0pOrcNi3savr3Ym3r9C4m8Yxy569ax+6qrSXryKVyZmcetIywqkL43tCJlbxZrPok/pX5MGNCC85qEMfnDrfySnHW6wzprKLiJiIicZYwxhI0YQaPXZ3HhzIU0e+BvvNLF8kA7J/6BXxD73kxChgwm4513iLtkIOlvv3PcBL2xnSJp1TOK9Z/vJTHu+HD3R5wOL14e3olAXye3vr2OnILiihreGU3BTURE5Cw3vNVwnjz/Sdb4+TK+KB73OxcR1WwLTV6ciH/r1iQ/8QQZb79zXLve1zWnVrgfy+dspyCv/MErsrYfLw/vRHxaDpMWbzmlwvdnGwU3ERER4arYq5je5xk2+vrwUoeBkLQVv5V30bDjBoI6NCJ52tPkLXgaNrwNG9+D7UvwcboZMLoN2en5fP/+L6e03R6x4Uy4uCUfb0rkzRWndtn1bKL6EyIiIgLAwCYDWZu8lrk736fXsDfokZmMWf0q9ZuuJv7XCA5Mm02TS1Jx+JaeGWtwLvWGzKHLZTGs/XQPjduG07xr3XJv99YLYtm4P5MnPt1BQkYeky8/B+9TeODhbKCfioiIiPxmQtcJNA1uyuRVU8ls3h/GLscxJY7oGbMoKvQjMWUQ9o71cO0bkPIzvNabrs13ERlTm2/f3cnerYdwFbvLtU0vL8PMEZ0Zc34T3vphDyPeWE1qVkEljbBmU3ATERGR3/g7/ZneZzoZBRlM/WFqyX1ngXXw796XupMmkb1yNekffQPth8L4b6F2NI75Qxhwzjd4eRk++ecm5kxcwVdvbSd+cxrFRa4/3iglDyv87YrWvHh9RzYnZHLlyyvYsC+jkkdb82geNxERETnO3G1z+fvavzO1x1SGtBgClFRPOHDvfWQtW0bjt+YQcO65UJQHSyfC+nkUN7qQ/e1eYNe2PPZsTqMgtxhvPwfBEf74+Dnx8Xfi4+/Ax89JbKcIGrQKK3Pb2xOPMP7ttSQfLuAv5zWi2O0mI7eIzNxCMnKKCPR1cO+AFvSMrVOVP5Iqowl4FdxERETKxW3djFs2js2pm3n/ivdpEtwEAFd2NnsGD8Gdm0vM/Pfwjo4uabDxXfj4Hmh6IfzlfVwuS8LODOI3pZGTWfBbwfrCvGLysosoKnDRY1AsnS4uu2h9Zm4hExZs4pudKQT7exMaWFK0PjTAm5+TskjIyOPydlE8fPk5RIf4V90PpgoouCm4iYiIlFtyTjKDPx5MhH8Eg5oNIjIgksiASMIPZFMw/n6Mjy8NXn6ZgM6dShr8+Cp8/iBc/g84d+wJ11ueovXW2uOCXX6Ri1nf7WbGf+IAuPWCZoy/oOkZU/dUwU3BTURE5JR8l/Adk76bRFbR76sbRB+ChxdB2GEXW8f2wf+KS2ke3Ixzlk7B7FsF47+DiBYnXO+xResvvaUdtcLKV7T+QGYeT322g083H6RRWADvj+9OVHDNP/um4KbgJiIicsqstWQVZZGSk0JKbgrJuckk5SSRkPgzPV5ZQeyuXD7qbnjvQi8ub9Sfx9f8G2dIQxizHJw+J133b0Xrvb249Jb2RMUGl7t/P8SlcfO8tbSKqs38cd1r/FQiCm4KbiIiIpXCFhWR+PjjHFnwAamdY/g8ZB8dCsPosXc/bu+GFLsCCOrVizp33IEzrOyHEdIP5vDZjM3k5xYx/G/nERjiW+5+LNmUyF3vbeDm3k2YfHnr0x2WR6nIvIiIiFQK4+1N/Ucfpe7kyURs2s+NX7tpsTqNhJwg3NkH8K0XSsb7C9h1yUAOzXkLW1h43DrCogK5/Pb2uIrcfDV3O9Zd/pNKV3Woz009GvP69/F8vjWpIoZWLSm4iYiIyGkxxhB24w00X/E9LX5azd7FT3HrLQ4e+WsgwR230PT9efh37EjK9OnsuvJKsr7++ri6pKH1Auk1pDn7d2Sw+ZuEU+rH5MvPoUODYB74YBN7D+VUxNCqHQU3ERERqRDO0FActWszqPk1PNvnWbZ4OxgbWEzOZ4NpNKw+DZ9/EuNwknDb7SQ9+uhx7dv0rk9M+zqs+nAXhw5kl3v7vk4Hr4zojJeX4da315P/Jyf/rUkU3ERERKTCXRxzMS9f9E92+wcyMaoe7pUvEvTTWJreGErYNQPInP8+mYs//F0bYwx9b2iFj7+DZbO3/emqC0drEBrA88M6sP3gER79eFtFDafaUHATERGRSnF+9Pk83H0Kq93ZzL3s/6DH7Zi93xHpPZeAyAKS/vYQ+ffVhccj4ckomDeIAA7R76ZzOHQghx//vfuUttuvVV1uuzCW937az2Mfb6fIVb7aqdWZgpuIiIhUmmuaXUP/Rv156ed5bO8yHO7bgRn0T+rf9xe8Avw5sK4x7k5jodONsH81vNabmMBttL0gmk3L97N/R/opbXfCxS0Z1SuG2SvjueGN1aRlnxlF6zUdiIiIiFSqwwWHuXbJtQQ4A3j/ivcJ8A4AIOfH1ewbPZral11G/WefwaTuhAU3waFfKTp/Mh98dz6HU/OIbhVKbKcImnaMwL/WyeeFO9aHGxKYtGgLYYE+vHpDFzo0DKmMIVYozeOm4CYiIuJRqw+u5uYvb2Zwi8FM7TH1t+VpM2eS+uJL1HvkEUKvHwYF2fDJvbBlAVkNB7El6H52bcniSFo+xkD9FiE0ah2OX5B3aeF6Bz7+ToJCfAkKLbvywtYDhxn/r3WkZhfw2FVt6N40nIzcwpKvnCKy8os4v3kEzSKDqurHcVIKbgpuIiIiHvfcuueYs3UOL/R9gYsaXQSAdbvZP248uatX03j+e/i3aQPWwro5sPRBCG6IHfcf0lINu9ansGt9KpnJucev3ED3q5vS+ZLGZRatT88p5K73NrAiLq3Mvjm9DCN7xnBX/+bU9vOuyGGXm4KbgpuIiIjHFbmKGPHZCBJzEpl36Twa1WqE08tJcXo68ddciy0upsHLLxHQuXNJg/jvYd5V0GE4DJoBlJTfKswrpjDfRWFeMQV5xRTmFbNzdRJxa1No3jWSvjedg3cZReuLXW4+25pEsctNaIAPIQHehAb44PAyzPhPHPPX7Cc80JcHB7ZkcOcGeHkdHwCrgoKbgpuIiEi1EH84nmGfDCOvOA+DIcwvjDr+dWh+JIBrZu0gMD2XgvtG0Wj4SML9wjFfPwHf/x2GzoU2g064XmstG77cx6qPdlGnQRCX3dq+3EXrtyQcZuqSrazfl0mHhiE8M7g9LevVOt0hl5uCm4KbiIhItRGXEce65HWk5qWSlpdGWl4aqXmppKfsZeyCI7TfY/nkXMMnA8Po2bAX//fzavzT4+HWHyA4+qTr3rMljWWzt+NwGgaOa0v95qHl6pvbbflo4wGe+mwHTi8vPr3rfMKDyl879XQouCm4iYiIVHvWWlKyDnLw6afw/fArEtvU5dF+h+jsH8uUDetw+jSlOHYYxseHkGHDcNQq+2xYRlIOn83cwpHUPK66uyPRLcsX3gC2JR7mmhk/cF6TMN4a1Q1HFV42VXBTcBMREalRMhYsIOnxJ6CoqMz3HaGhRNx1JyFDh2KczuPeL8gtYuH0dRQXuhg2pRt+geV/4GD+T/uYtHgL9/Rvzj39W5S7/alScFNwExERqXHytmwhZ9WP7PLO4OUD7+Ib5MXTRxKo1WcWKW8uJnfNGnyaxVJ34kSC+vQ5rn3K3iMsmr6O2C6RXDymTbm3b61lwgeb+HDDAeaO6kafFhEVMaw/pOCm4CYiIlKj/XTwJ+78+g7CC3J5PdtQ//wHyU4JJfn5lyjau4/APr1p8PzzeAUG/q7d2s/2sHrJbgaMbk2LbvXKvd3cwmKueeUHUrML+PSu84kK9q+oIZ3QyYJbtS95ZYxpaox50xiz8JjlgcaYdcaYKzzVNxEREaka3aK68frFb5DpG8jIWpD5yZ3U2ngrsXd0IPL2UeSsWMnBqY9w7AmpzgMbExUbzLfv/cKRQ3nl3m6Aj5MZN3SmoMjFHe9u8Hjd00oNbsaY2caYFGPM1mOWDzTG7DTGxBljJp1sHdba3dbaMWW89SCwoCL7KyIiItVX+4j2vH7JbNKcTh7tcgU29iLMhtmEH3qSiB7+HPnkEzLv7QdvD4F3roOFo/FK3UH/Ua2x1vLVWztwu8t/pTE2Iohpg9uzbm8G05f+XAkj+/Mq+4zbW8DAoxcYYxzAK8ClQGtguDGmtTGmnTHmk2O+IstaqTGmP7AdSK7c7ouIiEh10qZOG+7udDdfpW3kw45Xwn07oP8jhPeKILCJH8nLksiLT4LsZIj7Cl7vR+2Ej+h9XQsSf81k47J9p7TdKzvU5689GlPstsed1atKlX6PmzEmBvjEWtu29HUP4BFr7SWlrx8CsNY+/QfrWWitHVL6/ZNAICXBLw+4xlrrPubz44BxAI0aNeqyd+/eChyViIiIeIrbuhn35Tg2p23mgys/oHHtxgAUZ2QQf+1gjMNBk0ULcXjlw6IxsOd7bKeb+OLgGOK3ZHDeVU1p1jWS2uHlu1/N7bZVUk2hut3jFg3sP+p1QumyMhljwo0xrwKdjgp5k6219wDvAq8fG9pKPzPLWtvVWts1IqJqngIRERGRyudlvHji/Cfw9vJm0neTKHKXTBniDA2lwfPPUZScTOLDk7FBkXDjR9B7AmbDPC4sfoC6DX1Y9eEu/jV5FQunr2XTV/vJzij4c9v1UAmso3nijNtQ4BJr7djS1zcC3ay1d1ZWH/RUqYiIyJln2d5l3Pef+7i53c3c1fmu35anz5tH8lNPE/nAA4SPGV2y8Jcv4cNx4HZx+PIPiEusR9y6FNL2ZwPgG+DE29dR8uXnxMfPQbMukbQ+v36ZResr08nOuB0/Y13lSwAaHvW6AZDogX6IiIhIDTag8QAGNRvEG1veoFd0L7rU7QJA6I03krt2HSnPPYd3dDS1B14CLS6G8d/BW1cQ/NXNdLl1BV0GxpCZnMvujalkZxZQlF9MUb6LwgIXOZkF/OednSTFH+GC4S1weh9ftN4TPHHGzQn8AlwEHADWAH+x1m6rrD7ojJuIiMiZKacoh6EfDyW3KJde0b2oG1C35MvWou7/zYKtvxD54ETCR44sabD/J5g9ENoNgWtnnXC91m356dN41n66h8iY2lw6vi1BoeUrWn+qPDYBrzHmPeBCoA4lT4BOtda+aYy5DHgBcACzrbVPVlonUHATERE5k+04tINpP03jQPYB0vLScFkXAN5Fljs/dtN9p2XDhdEkjOpP87CWXLJ/GwHfPQuD3ywJcCexe2Mqy+dsx+nr4NJxbYlqFlLp41HlBAU3ERGRs4LL7SI9P52U3BQO5hwkPmMXYW8sofXy3axp5eCFK6B1VAdmHEyiduqvcOtKCGl40nUeSsxm6cwtZKXn03tYC9r2OeEzlRVCwU3BTURE5KyWPncuydOmU9CyEV+EJtAoP5BuyemYQn+KCSaoVy8i7r0H73pll8XKzyli2extOJxeXHpLu0p9YEHBTcFNRETkrHfkiy9JfOgh3EWFHPJ3kVvLQazJxr9+G7I27AOHg/DRowkfM/q4mqdQMo+bq9iNt0/lPqig4KbgJiIiIoAtKgKnk7XJa7njqzsIcxXzxv79RPR4mtSPt3Fk6VKcERFE3HM3wYMGYRxV/zRpdZuAV0RERMQjjLc3xhjOrXcub1z8BkecvtxUvy4Hf5hIdIOlxDwwEO96ERycPIUDE+73aHmrsuiMm4iIiJy1dqbv5OYvxxLu5cu7BbXx3/U1FsOhpA6k/ieZukO6ENa3BbhdYF0QGgPnjq3UPumMm4iIiEgZWoa1ZFrv6cTlJTM9tj3cvQnTZwLhzZIIis4jedFacj96BX6cAT+9AT9/5tH+KriJiIjIWa1ndE/GtB3Dol8XsTRzO/Sbgpmwg/qLN+HdoBEHtrSm+PadMCUJblzs0b4quImIiMhZ7/ZOt9MxoiOPrnqUfUf2gTE4goNp8OILuNLTSXxgItbl8nQ3FdxEREREvL28eabPMziMg/u/vZ9CVyEAfq1bU3fKZHJWriTt1Vc93EsFNxEREREAooKieLzX4+xI38Hz657/bXnI0KEEX30Vaf98heyVKz3YQ3B6dOsiIiIi1Ui/Rv0Ycc4I3t7xNm7rJjoomlC/UMJuvoTQzRtI/PuzNO/Zs1IrJ5yMgpuIiIjIUe7rch97Du9hwc4FFNvi35ZHXmJpHt2eVz0U2kDBTUREROR3fBw+vDrgVay1HCk8QkZ+BpkFmaTnp+Pv9Pdo3xTcRERERMpgjCHYN5hg32BPd+U3ejhBREREpIZQcBMRERGpIRTcRERERGoIBTcRERGRGkLBTURERKSGUHATERERqSEU3ERERERqCAU3ERERkRpCwU1ERESkhlBwExEREakhFNxEREREaggFNxEREZEaQsFNREREpIZQcBMRERGpIRTcRERERGoIY631dB8qnTEmFdhbBZuqA6RVwXakfLRfqi/tm+pJ+6X60r6pnip6vzS21kaU9cZZEdyqijFmrbW2q6f7Ib+n/VJ9ad9UT9ov1Zf2TfVUlftFl0pFREREaggFNxEREZEaQsGtYs3ydAekTNov1Zf2TfWk/VJ9ad9UT1W2X3SPm4iIiEgNoTNuIiIiIjWEgpuIiIhIDaHgVgGMMQONMTuNMXHGmEme7s/ZzBjT0BjzjTFmhzFmmzHm7tLlYcaYZcaYX0v/DPV0X89GxhiHMWaDMeaT0tdNjDGrS/fL+8YYH0/38WxkjAkxxiw0xvxceuz00DHjecaYe0t/j201xrxnjPHTMeMZxpjZxpgUY8zWo5aVeYyYEi+VZoLNxpjOFdkXBbfTZIxxAK8AlwKtgeHGmNae7dVZrRiYYK09B+gO3F66PyYBX1lrmwNflb6Wqnc3sOOo19OB50v3SwYwxiO9kheBz621rYAOlOwjHTMeZIyJBu4Culpr2wIO4Hp0zHjKW8DAY5ad6Bi5FGhe+jUOmFmRHVFwO33dgDhr7W5rbSEwH7jaw306a1lrD1pr15d+n0XJP0DRlOyTuaUfmwsM8kwPz17GmAbA5cAbpa8N0A9YWPoR7RcPMMbUBvoAbwJYawuttZnomKkOnIC/McYJBAAH0THjEdba74D0Yxaf6Bi5GphnS/wIhBhjoiqqLwpupy8a2H/U64TSZeJhETfSugAAA9ZJREFUxpgYoBOwGqhrrT0IJeEOiPRcz85aLwATAXfp63Ag01pbXPpax45nNAVSgTmll7HfMMYEomPGo6y1B4C/A/soCWyHgXXomKlOTnSMVGouUHA7faaMZZpjxcOMMUHAIuAea+0RT/fnbGeMuQJIsdauO3pxGR/VsVP1nEBnYKa1thOQgy6Lelzp/VJXA02A+kAgJZfgjqVjpvqp1N9tCm6nLwFoeNTrBkCih/oigDHGm5LQ9o61dnHp4uT/nqou/TPFU/07S/UCrjLG7KHkdoJ+lJyBCym9DAQ6djwlAUiw1q4ufb2QkiCnY8az+gPx1tpUa20RsBjoiY6Z6uREx0il5gIFt9O3Bmhe+qSPDyU3jy7xcJ/OWqX3Tb0J7LDWPnfUW0uAv5Z+/1fg31Xdt7OZtfYha20Da20MJcfI19baEcA3wJDSj2m/eIC1NgnYb4xpWbroImA7OmY8bR/Q3RgTUPp77b/7RcdM9XGiY2QJcFPp06XdgcP/vaRaEVQ5oQIYYy6j5OyBA5htrX3Sw106axljzge+B7bwv3upHqbkPrcFQCNKfiEOtdYee6OpVAFjzIXA/dbaK4wxTSk5AxcGbABusNYWeLJ/ZyNjTEdKHhrxAXYDoyj5j72OGQ8yxjwKDKPkafkNwFhK7pXSMVPFjDHvARcCdYBkYCrwEWUcI6VB+5+UPIWaC4yy1q6tsL4ouImIiIjUDLpUKiIiIlJDKLiJiIiI1BAKbiIiIiI1hIKbiIiISA2h4CYiIiJSQyi4iYiIiNQQCm4iIuVkjHnMGNO/9Pt7jDEBnu6TiJwdNI+biMhpKC3j1dVam1aONg5rravyeiUiZyqdcRMRAYwxMcaYHcaY140x24wxXxpj/E/w2beMMUOMMXdRUgD8G2PMN6XvXWyMWWWMWW+M+cAYE1S6fI8x5v+MMSuAoVU2MBE5oyi4iYj8T3PgFWttGyATGHyyD1trX6KkeHRfa21fY0wdYArQ31rbGVgL3HdUk3xr7fnW2vmV030ROdM5Pd0BEZFqJN5au7H0+3VATDnbdwdaAytLyhXiA6w66v33T7eDInJ2U3ATEfmfo4t1u4AyL5WehAGWWWuHn+D9nFPqlYhIKV0qFRE5PVlArdLvfwR6GWOaARhjAowxLTzWMxE54yi4iYicnlnAUmPMN9baVGAk8J4xZjMlQa6VJzsnImcWTQciIiIiUkPojJuIiIhIDaGHE0RETsAY8wrQ65jFL1pr53iiPyIiulQqIiIiUkPoUqmIiIhIDaHgJiIiIlJDKLiJiIiI1BAKbiIiIiI1xP8D0STMyWEfh5gAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 720x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "G[3, 3] = 1\n",
    "A = pagerank_matrix(G)\n",
    "\n",
    "plt.figure(figsize=(10, 7))\n",
    "for n in range(5):\n",
    "    plt.semilogy(range(100), power_method(A, np.random.randn(5), 100)[2], label=f'guess_{n}')\n",
    "plt.legend()\n",
    "plt.xlabel('n_iter')\n",
    "plt.ylabel('residual');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 351,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.5+0.5j, -0.5-0.5j,  1. +0.j ,  1. +0.j , -0.5+0.j ])"
      ]
     },
     "execution_count": 351,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.eigvals(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 352,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.5, -0.5,  1. ,  1. , -0.5])"
      ]
     },
     "execution_count": 352,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.eigvals(A).real"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we've got rid of the different-sign-equal-norm problem and the algorithm converges finely."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 357,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lambda: 1.0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[ 0.12612631,  0.25225261,  0.25225261, -0.82792724, -0.41396362],\n",
       "       [-0.15767091, -0.31534183, -0.31534183,  0.78804007,  0.39402004],\n",
       "       [-0.12844586, -0.25689171, -0.25689171, -0.82535566, -0.41267783],\n",
       "       [-0.33280716, -0.66561431, -0.66561431,  0.05023604,  0.02511802],\n",
       "       [-0.02119306, -0.04238612, -0.04238612, -0.89261758, -0.44630879],\n",
       "       [ 0.05832143,  0.11664286,  0.11664286,  0.88063045,  0.44031523],\n",
       "       [-0.18401663, -0.36803326, -0.36803326,  0.7457833 ,  0.37289165],\n",
       "       [-0.32530415, -0.6506083 , -0.6506083 ,  0.19513047,  0.09756524],\n",
       "       [ 0.29221629,  0.58443259,  0.58443259,  0.43033637,  0.21516819],\n",
       "       [ 0.19772121,  0.39544243,  0.39544243, -0.72008716, -0.36004358]])"
      ]
     },
     "execution_count": 357,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(f'Lambda: {power_method(A, np.random.randn(5), 100)[1]}')\n",
    "np.vstack([power_method(A, np.random.randn(5), 100)[0] for _ in range(10)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matrix A has an eigenspace of dimensionality 2 corresponding to eigenvalue 1. It means that algorithm may converge to any vector in such a subspace."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "G = np.array([\n",
    "    [0, 1, 0, 0, 0],\n",
    "    [0, 0, 1, 0, 0],\n",
    "    [1, 1, 0, 0, 0],\n",
    "    [0, 0, 0, 0, 1],\n",
    "    [0, 0, 0, 1, 0]\n",
    "])\n",
    "A = pagerank_matrix(G)\n",
    "\n",
    "d = 0.97\n",
    "Ad = d * A + (1 - d) / A.shape[0] * np.ones_like(A)\n",
    "\n",
    "plt.figure(figsize=(10, 7))\n",
    "for n in range(5):\n",
    "    plt.semilogy(range(100), power_method(Ad, np.random.randn(5), 100)[2], label=f'guess_{n}')\n",
    "plt.legend()\n",
    "plt.xlabel('n_iter')\n",
    "plt.ylabel('residual');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we have a matrix $A$ with eigenvalues $\\lambda_1 \\dots \\lambda_n$ in the descending order and corresponding eigenvectors $v_1 \\dots v_n$, then matrix $A - \\lambda_1 v_1 v_1^T$ has eigenvalues $0, \\lambda_2 \\dots \\lambda_n$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 647,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9700261138420608"
      ]
     },
     "execution_count": 647,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eig_vec, lmbda, _ = power_method(Ad, np.random.randn(5), 100)\n",
    "eig_vec = eig_vec.reshape(-1, 1)\n",
    "power_method(Ad - lmbda * np.outer(eig_vec, eig_vec), np.random.randn(5), 1000)[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The second largest eigenvalue equals $d$, and the convergence rate $q = \\frac{|\\lambda_2|}{|\\lambda_1|} = \\lambda_2 = d$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# INPUT:  A - np.ndarray (2D), d - float (from 0.0 to 1.0), x - np.ndarray (1D, size of A.shape[0/1])\n",
    "# OUTPUT: y - np.ndarray (1D, size of x)\n",
    "def pagerank_matvec(A, d, x): # 2 pts\n",
    "    return d * (A @ x) + (1 - d) / x.shape[0] * x.sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.random.randn(5)\n",
    "np.isclose(Ad @ x, pagerank_matvec(A, d, x)).all()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.sparse import random as rand_mat\n",
    "\n",
    "N = 10000\n",
    "A = rand_mat(N, N, density=100 / (N * N), format='csr', dtype='float32')\n",
    "Ad = d * A.todense() + (1 - d) / A.shape[0] * np.ones_like(A)\n",
    "x = np.random.rand(A.shape[0], 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 374 µs, sys: 175 µs, total: 549 µs\n",
      "Wall time: 381 µs\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "ans = pagerank_matvec(A, d, x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 151 ms, sys: 2.99 ms, total: 154 ms\n",
      "Wall time: 38.1 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "ans = Ad @ x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### DBLP: computer science bibliography\n",
    "\n",
    "Download the dataset from [here](https://goo.gl/oZVxEa), unzip it and put `dblp_authors.npz`  and `dblp_graph.npz` in the same folder with this notebook. Each value (author name) from `dblp_authors.npz` corresponds to the row/column of the matrix from `dblp_graph.npz`. Value at row `i` and column `j` of the matrix from `dblp_graph.npz` corresponds to the number of times author `i` cited papers of the author `j`. Let us now find the most significant scientists according to PageRank model over DBLP data.\n",
    "\n",
    "* (4 pts) Load the weighted adjacency matrix and the authors list into Python using ```load_dblp(...)``` function. Print its density (fraction of nonzero elements). Find top-10 most cited authors from the weighted adjacency matrix. Now, make all the weights of the adjacency matrix equal to 1 for simplicity (consider only existence of connection between authors, not its weight). Obtain the PageRank matrix $A$ from the adjacency matrix and verify that it is stochastic.\n",
    " \n",
    " \n",
    "* (1 pts) In order to provide ```pagerank_matvec``` to your ```power_method``` (without rewriting it) for fast calculation of $A_dx$, you can create a ```LinearOperator```: \n",
    "```python\n",
    "L = scipy.sparse.linalg.LinearOperator(A.shape, matvec=lambda x, A=A, d=d: pagerank_matvec(A, d, x))\n",
    "```\n",
    "Calling ```L@x``` or ```L.dot(x)``` will result in calculation of ```pagerank_matvec(A, d, x)``` and, thus, you can plug $L$ instead of the matrix $A$ in the ```power_method``` directly. **Note:** though in the previous subtask graph was very small (so you could disparage fast matvec implementation), here it is very large (but sparse), so that direct evaluation of $A_dx$ will require $\\sim 10^{12}$ matrix elements to store - good luck with that (^_<).\n",
    "\n",
    "\n",
    "* (2 pts) Run the power method starting from the vector of all ones and plot residuals $\\|A_dx_k - \\lambda_k x_k\\|_2$  as a function of $k$ for $d=0.85$.\n",
    "\n",
    "\n",
    "* (1 pts) Print names of the top-10 authors according to PageRank over DBLP when $d=0.85$. Comment on your findings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.sparse import load_npz\n",
    "import numpy as np\n",
    "def load_dblp(path_auth, path_graph):\n",
    "    G = load_npz(path_graph).astype(float)\n",
    "    with np.load(path_auth) as data: authors = data['authors']\n",
    "    return G, authors\n",
    "G, authors = load_dblp('dblp_authors.npz', 'dblp_graph.npz')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Density is 4.5e-05\n"
     ]
    }
   ],
   "source": [
    "n_nnz = G.getnnz()\n",
    "n_vals = G.shape[0] * G.shape[1]\n",
    "print(f'Density is {n_nnz / n_vals:.3}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Scott Shenker\n",
      "Andrew Zisserman\n",
      "Hari Balakrishnan\n",
      "Jiawei Han\n",
      "Anil K. Jain\n",
      "Cordelia Schmid\n",
      "Jitendra Malik\n",
      "Ion Stoica\n",
      "David E. Culler\n",
      "David G. Lowe\n"
     ]
    }
   ],
   "source": [
    "top_n = 10\n",
    "citations = np.array(G.sum(0)).ravel()\n",
    "print(*authors[np.argsort(-citations)[:top_n]], sep='\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "G.data = np.ones_like(G.data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = pagerank_matrix(G)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "col_sum = np.array(A.sum(0)).ravel()\n",
    "np.isclose(col_sum, 1).all()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.sparse.linalg import LinearOperator\n",
    "d = 0.85\n",
    "L = LinearOperator(A.shape, matvec=lambda x, A=A, d=d: pagerank_matvec(A, d, x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x, l, res = power_method(L, np.ones(A.shape[1]), n_iter=50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(res);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}