{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Concept(s)-clé(s) et théorie\n",
    "\n",
    "#### Définition: Valeur propre et vecteur propre d'une application linéaire\n",
    "\n",
    "Soient $V$ un $\\mathbb{R}$-espace vectoriel et $T: V \\rightarrow V$ une transformation linéaire. On dit que $\\lambda \\in \\mathbb{R}$ est une valeur propre de $T$ s'il existe $v \\in V$ non-nul tel que $T(v)=\\lambda v$. Aussi, si $\\lambda \\in \\mathbb{R}$ est une valeur propre de $T$, alors tout vecteur non-nul $v \\in V$ tel que $T(v)=\\lambda v$ s'appelle un vecteur propre de $T$ correspondant à la valeur propre $\\lambda$.\n",
    "\n",
    "#### Définition: Valeur propre et vecteur propre d'une matrice\n",
    "Soit $A \\in M_{n \\times n} \\ (\\mathbb{R})$ . On dit que $\\lambda \\in \\mathbb{R}$ est une valeur propre de $A$ s'il existe $X \\in M_{n \\times 1} (\\mathbb{R})$ non-nul tel que $A X=\\lambda X$. Aussi, si $\\lambda \\in \\mathbb{R}$ est une valeur propre de $A$, alors toute solution non-nulle de $A X=\\lambda X$ s'appelle un vecteur propre de $A$ correspondant à la valeur propre $\\lambda$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import plotly\n",
    "import plotly.graph_objects as go\n",
    "import sympy as sp\n",
    "from IPython.display import display, Latex\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def vector_plot_3D(v, b):\n",
    "    fig = go.Figure()\n",
    "\n",
    "    fig.add_trace(go.Scatter3d(x=[0, v[0]], y=[0, v[1]], z=[0, v[2]],\n",
    "                        line=dict(color='red', width=4),\n",
    "                        mode='lines+markers',\n",
    "                        name='$v$'))\n",
    "\n",
    "    fig.add_trace(go.Scatter3d(x=[0, b[0]], y=[0, b[1]], z=[0, b[2]],\n",
    "                        line=dict(color='royalblue', width=4, dash='dash'),\n",
    "                        mode='lines+markers',\n",
    "                        name='$A \\ v$'))\n",
    "\n",
    "    fig.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def CheckEigenVector(A, v):\n",
    "    # Check Dimensions\n",
    "    if A.shape[0] != A.shape[1] or v.shape[0] != A.shape[1]:\n",
    "        raise ValueError('Dimension problem, A should be square (n x n) and v (n x 1)')\n",
    "\n",
    "    if v==sp.zeros(v.shape[0],1):\n",
    "        display(Latex(\"$v$ est le vecteur nul, il ne peut pas être un vecteur propre par définition.\"))\n",
    "    \n",
    "    else:\n",
    "        # Matrix Multiplication\n",
    "        b = A * v\n",
    "\n",
    "        # Print some explanation about the method\n",
    "        display(Latex(\"On voit que $ b = A v = \" + sp.latex(b) + \"$\"))\n",
    "        display(Latex(\"On cherche alors un nombre $\\lambda \\in \\mathbb{R}$ tel que $b = \\lambda v\" \\\n",
    "               + \"\\Leftrightarrow\" + sp.latex(b) + \" = \\lambda\" + sp.latex(v) + '$'))\n",
    "\n",
    "\n",
    "        # Symbol for lambda\n",
    "        l = sp.symbols('\\lambda', real=True)\n",
    "\n",
    "        # Check if there is a solution lambda of eq: A*v = lambda * v\n",
    "        eq = sp.Eq(b, l*v)\n",
    "        sol = sp.solve(eq, l)\n",
    "\n",
    "        # If there is l st b = l*v\n",
    "        if sol:\n",
    "            display(Latex(\"Il existe bien une solution pour $\\lambda$. Le vecteur $v$ est donc un vecteur \\\n",
    "                          propre de la matrice $A$.\"))\n",
    "            display(Latex(\"La valeur propre associée est $\\lambda = \" + sp.latex(sol[l]) + \"$.\"))\n",
    "        # Otherwise\n",
    "        else:\n",
    "            display(Latex(\"L'equation $b = \\lambda v$ n'a pas de solution.\"))\n",
    "            display(Latex(\"Le vecteur $v$ n'est donc pas un vecteur propre de la matrice $A$.\"))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Exemple 1**\n",
    "\n",
    "Pour savoir si un vecteur $v \\in M_{n \\times 1} \\ (\\mathbb{R})$ est un vecteur propre de la matrice $A\\in M_{n \\times n} \\ (\\mathbb{R})$, il suffit de vérifier que les vecteurs $v$ et $b = A \\ v$ sont colinéaires. Il est possible de visualiser cela graphiquement pour des vecteurs de dimension $n=2$ où $n=3$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Definition de la matrice A et du vecteur v (3D)\n",
    "# On utilise des numpy array pour les plots\n",
    "v = np.array([1, 1, 1])\n",
    "A = np.array([[1, 1, 1], [1, 1, 1], [1, 1, 1]])\n",
    "\n",
    "# Multiplication de v par A\n",
    "b = A@v\n",
    "\n",
    "# Plot\n",
    "vector_plot_3D(v, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 1\n",
    "Etant donné une matrice carrée $A \\in M_{n \\times n} \\ (\\mathbb{R})$ et un vecteur $v \\in M_{n \\times 1} \\ (\\mathbb{R})$. Déterminez si $v$ est un vecteur propre de la matrice $A$. Si tel est le cas, trouvez la valeur propre $\\lambda \\in \\mathbb{R}$ associée. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Les matrices ou/et vecteurs peuvent dépendre du paramètre x\n",
    "x = sp.symbols('x')\n",
    "\n",
    "# a)\n",
    "A_1 = sp.Matrix([[1, 1, 1], [1, 1, 1], [1, 1, 1]])\n",
    "v_1 = sp.Matrix([1, 1, 1])\n",
    "\n",
    "display(Latex(\" $A =\" + sp.latex(A_1) + \"\\hspace{20mm} v= \" + sp.latex(v_1) + \"$\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Affiche la solution pour A_1 et v_1\n",
    "CheckEigenVector(A_1, v_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# b)\n",
    "A_2 = sp.Matrix([[4*x, 8*x], [1, 2]])\n",
    "v_2 = sp.Matrix([2, -1])\n",
    "\n",
    "display(Latex(\" $A =\" + sp.latex(A_2) + \"\\hspace{20mm} v= \" + sp.latex(v_2) + \"$\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Print the solution for A_2 and v_2\n",
    "CheckEigenVector(A_2, v_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# c)\n",
    "A_3 = sp.Matrix([[1, 2], [1, 2]])\n",
    "v_3 = sp.Matrix([0, 0])\n",
    "\n",
    "display(Latex(\" $A =\" + sp.latex(A_3) + \"\\hspace{20mm} v= \" + sp.latex(v_3) + \"$\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Print the solution for A_3 and v_3\n",
    "CheckEigenVector(A_3, v_3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice 2\n",
    "En utilisant la définition d'une valeur propre donnée plus haut, vérifiez si un nombre donné $\\lambda$ est une valeur propre de la matrice $A \\in M_{n \\times n} \\ (\\mathbb{R})$. Si oui trouvez un vecteur propre correspondant à $\\lambda$.\n",
    "\n",
    "##### Méthode: \n",
    "Poser $A v  = \\lambda v \\Leftrightarrow (A - \\lambda I) v = 0 $  et étudier le nombre de solutions du système.\n",
    "\n",
    "- Si le système a une unique solution ($v$ = 0), alors $\\lambda$ n'est pas une valeur propre de la matrice A.\n",
    "- Si le système a une infinité de solutions, alors $\\lambda$ est une valeur propre de $A$.\n",
    "\n",
    "Si $\\lambda$ est bien une valeur propre de $A$, alors n'importe quelle solution $v$ du système $A v = \\lambda v$ est un vecteur propre associé à $\\lambda$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A_1 = sp.Matrix([[2, 0], [1, 2]])\n",
    "l_a = 2\n",
    "\n",
    "# A remplir pour vérifier avec la fonction ch8_1_exo_2\n",
    "# Mettre vp = True si c'est une valeur propre de A. False sinon.\n",
    "vp_1 = False  \n",
    "# Entrez un vecteur propre associé à lambda si c'est une valeur propre, sinon laissez les 0\n",
    "v_1 = sp.Matrix([0, 0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ch8_1_exo_2(A, l, v):\n",
    "    eig = list(A.eigenvals().keys())\n",
    "        \n",
    "    if l in eig:\n",
    "        display(Latex(\"$\\lambda = \" + str(l) + \"$ est une valeur propre de la matrice $A$.\"))\n",
    "        \n",
    "        # Check the eigen vector v\n",
    "        z = sp.simplify(A*v-l*v)\n",
    "        if z==sp.zeros(2,1):\n",
    "            display(Latex(\"$v$ est bien un vecteur propre de $A$ associé à $\\lambda = \" + str(l) + \"$ car on a:\"))\n",
    "            display(Latex(\"$$\"+ sp.latex(A) + sp.latex(v) + \"= \\lambda\" + sp.latex(v) + \"$$\"))\n",
    "        else:\n",
    "            display(Latex(\"$v$ n'est pas un vecteur propre de $A$ associé à $\\lambda = \" + str(l) + \"$ car on a:\"))\n",
    "            display(Latex(\"$$\"+ sp.latex(A) + sp.latex(v) + \"\\\\neq \\lambda\" + sp.latex(v) + \"$$\"))\n",
    "    else:\n",
    "        display(Latex(\"$\\lambda$ n'est pas une valeur propre de $A$.\"))\n",
    "        \n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ch8_1_exo_2(A, l, v)"
   ]
  },
  {
   "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}