{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", " Calculs matricielles\n", "
\n", "

Navigation dans la page

\n", "

\n", " Si c'est votre première visite dans ce TP, lisez attentivement chacun des points détaillé après ce paragraphe.
\n", " Si vous avez déjà commencer à travailler sur ce TP et que vous souhaiter vous déplacer rapidement dans une partie précise vous pouvez choisir la partie que vous souhaitez rejoindre ci-dessous.
\n", "

\n", " Menu de navigation\n", " \n", "
\n", "

\n", "\n", "
\n", " Technologie jupyter\n", "

\n", " La technologie jupyter permet d'exécuter du code python par un simple clique sur Executer ci-dessus.
\n", " Les morceaux de code de cette page sont interprétées case par case. Pour savoir quelle case a été interprétée avant une autre, il suffit de repérer le numéro devant la case.
\n", " Une fois qu'une case a été interprétée (=exécutée), la page garde en mémoire les variables et fonctions lues
\n", " La plateforme propose quelques outils de purge de la mémoire : \n", "

\n", "

\n", "
\n", "

SAUVEGARDER VOTRE TRAVAIL

\n", "

\n", " Pour ne pas perdre votre travail pensez à le sauvegarder régulièrement. Par défault, la sauvegarde par un clic sur la disquette en haut à gauche de page, ou par le racourci clavier classique ctrl+S\n", " est une sauvegarde en local, sur le serveur de jupyter. Vous pouvez et devez très régulièrement sauvegarder votre travail sur votre support personnel de sauvegarde (clef USB, se l'envoyer par mail etc). Ce faisant vous disposerez d'un fichier .ipynb (IPYthon NoteBook) qu'il vous suffira de recharger pour avancer. Après le rechargement assurez vous que les fonctionnalités anciennement developpées et variables utilisées sont bien dans la mémoire de la page (en rééxecutant les cases, ou plus rapidement par Kernel > Restart & Run All.

\n", "

A NOTER : vous pouvez travailler sur le tp (et tout autre fichier .ipynb) hors connexion en installant une version local du notebook de jupyter. Il faut que votre machine possède un interpreteur de python et que vous soyez connecter à internet.\n", "

    \n", "
  1. Lancer un terminal
    2. \n", "
  2. Taper la commande suivante : pip install jupyterlab
    3. \n", "
  3. Une fois l'installation terminée portez votre attention sur les dernières lignes affichées dans votre terminal vous invitant probablement à taper une ligne de commande pour faire une mise à jour
    4. \n", "
  4. Pour lancer notebook de jupyter, taper dans votre termial : jupyter notebook
    5. \n", "
  5. Votre simulateur de serveur est lancé. Il ne faut pas fermer votre terminal, auquel cas votre simulateur de serveur s'interompera. Suivez le lien indiqué dans les dernières lignes de votre terminal pour vous diriger vers votre espace local. L'interface se présente comme celle que vous trouverez sur le web. Votre travail sera cependant toujours enregistré et jamais perdu même si vous le consultez après plusieurs jours
    6. \n", "
\n", "

\n", "
\n", "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", " Matrices\n", "
\n", "
\n", " Menu de navigation\n", " \n", "
\n", "L'année dernière en algèbre linéaire nous avons introduit la notion de matrice. Nous avons vu en particulier les liens qui existe entre la résolution de système linéaire et le langage matriciel. \n", "\n", "\n", "Par exemple, résoudre le système\n", "$$\n", "(S) \\left\\{\n", "\\begin{array}{rcrcrcr}\n", "3x&-&y&&&=&4\\\\\n", "x&+&y&-&2z&=&-4\\\\\n", "-x&+&2y&+&3z&=&3\n", "\\end{array}\n", "\\right.\n", "$$\n", "est équivalent à résoudre le système matricielle $ A.X=B$ où\n", "$$A=\n", "\\begin{pmatrix}\n", "3&-1&0\\\\\n", "1&1&-2\\\\\n", "-1&2&3\n", "\\end{pmatrix}, \\quad\n", "X=\n", "\\begin{pmatrix}\n", "x\\\\\n", "y\\\\\n", "z\n", "\\end{pmatrix},\\quad \n", "B=\n", "\\begin{pmatrix}\n", "4\\\\\n", "-4\\\\\n", "3\n", "\\end{pmatrix}\n", "$$\n", "\n", "Ce n'est pas claire, posez le calcul matriciel sur papier, vous serez convaincu !\n", "\n", "L'avantage de cette notation permet de revenir à une équation plus simple. En effet, classiquement (c'est à dire avec des nombres réelles) résoudre $ ax=b$ est très facile. La solution est $ x=\\dfrac{b}{a}$ que l'on peut encore noter $ x=a^{-1}b$ (simplement parce que $\\frac{b}{a}=\\frac{1}{a}\\times b=a^{-1}b$). Nous savons d'ailleurs que pour pouvoir écrire cette égalité il faut (et il suffit) que $ a\\neq 0$ . Lorsque l'on travaille avec les matrices (que l'on peut voir comme des gros nombres réels) nous avons, comme pour les nombres réels, la même égalité à savoir que la solution du système $ (S)$ est la solution de l'équation matricielle $ AX=B$ qui est $ X=A^{-1}B$ . Sauf que la condition $ A\\neq 0$ n'est pas suffisante pour pouvoir affirmer que la solution existe. Un outil va nous permettre de nous rapprocher de ce formalisme : le déterminant.\n", "\n", "Pour tous entiers $ n, m\\in \\mathbb{N}_{{>}0}$ , nous noterons $ \\mathcal{M}_{n, m}$ l'ensemble des matrices à $ n$ lignes et $ m$ colonnes à coefficients réels.\n", "On notera simplement $ \\mathcal{M}_n=\\mathcal{M}_{n,n}$ .\n", "Soit $ M\\in \\mathcal{M}_{n,m}$ on notera $ M_{i, j}$ le coefficient à l'intersection de la $ i$ -ème ligne et $ j$ -ème colonne. On pourra alors noter $ M=(M_{i,j})_{i,j}$ .\n", "Par exemple, avec la matrice $ A$ introduite ci dessus $ A_{1,2}=-1$ ou encore $ A_{3, 3}=3$.\n", "\n", "
\n", "

Matrices en Python

\n", "

\n", " Informatiquement une matrice sera considérée comme une liste à deux entrées. Le premier indice correspondera au numéro de la ligne et le second au numéro de la colonne. Attention ces numéros sont informatiques : ils commencent à $0$ et non $1$.\n", "

\n", "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Quelques fonctions pour aider

\n", "Vous pourrez utiliser les fonctions suivantes pour le reste du TP. Au dela du fait qu'elles soient gratuites, n'hésitez pas à vous inspirer du code pour le reste de ce TP." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

printM : permet d'afficher une matrice, comme un print... mais pour les matrices

" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def printM(M) : \n", " try : \n", " n=len(M)#Nombre de libre\n", " if(n>0) : m=len(M[0])#Nombre de colonne\n", " else : m=0 \n", " for i in range(n) :\n", " for j in range(m) : M[i][j]\n", " except : \n", " print(\"\")\n", " if(n==0 or m==0) : \n", " print(\"\")\n", " return #Force l'arêt de la procédure\n", " \n", " res=\"\"\n", " for i in range(n) :\n", " for j in range(m) :\n", " print(round(M[i][j], 3), end='')#On arrondi l'affichage à 10^-3 pour que cela reste esthétique\n", " if(jMat0 : renvoie la matrice nulle\n", "

Cette fonction renvoie la matrice nulle.
ATTENTION : Z=Mat0(3,2) créera dans la mémoire la matrice Z. Pour l'utiliser, il suffira de l'utiliser comme n'importe quelle variable. En particulier, pour l'afficher, il faudra appeler printM(Z).

\n", "\n", "

Le premier paramètre de cette fonction représente le nombre de ligne et le second le nombre de colonne. Ce second paramètre est optionnelle, cela signifie que s'il n'est pas spécifié, il vaudra -1. Si vous observez la ligne 8, vous verrez que dans ce cas, la fonction s'appelle elle-même et met comme valeur du second paramètre le nombe de ligne. Cela signifie (que tu vivras ta vie, sans aucun souciiiiis, philosophiiiiiie) que Z=Mat0(5) renverra une matrice carrée nulle à 5 lignes et 5 colonnes.

" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def Mat0(n, m=-1) : \n", " try :\n", " n=int(n)\n", " m=int(m)\n", " except :\n", " return []\n", " \n", " if(m<0) : return Mat0(n, n)\n", " \n", " res=[]\n", " for i in range(n) : \n", " res.append([])\n", " for j in range(m) : res[i].append(0)\n", " return res" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#Test\n", "\n", "Z1=Mat0(3,2)\n", "print(\"Matrice nulle à 3 lignes et 2 colonnes :\")\n", "printM(Z1)\n", "\n", "Z2=Mat0(2,3)\n", "print(\"Matrice nulle à 2 lignes et 3 colonnes :\")\n", "printM(Z2)\n", "\n", "Z3=Mat0(5)\n", "print(\"Matrice carrée nulle à 5 lignes :\")\n", "printM(Z3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

MatRand : Tire une matrice au hasard

" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from random import randint #Import de la bibliothèque de gestion de l'aléa (pseudo aléa en fait)\n", "def MatRand(n, m=-1, coefmin=-9, coefmax=9) :\n", " try :\n", " n=int(n)\n", " m=int(m)\n", " coefmin=int(coefmin)\n", " coefmax=int(coefmax)\n", " except :\n", " return []\n", " \n", " if(coefmin>coefmax) : return MatRand(n, m, coefmax, coefmin)\n", " if(m<0) : return MatRand(n, n, coefmax, coefmin)\n", " \n", " res=[]\n", " for i in range(n) :\n", " res.append([])\n", " for j in range(m) :\n", " res[i].append(randint(coefmin, coefmax))\n", " return res" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#Tests\n", "\n", "print(\"Matrice au hasard à 3 lignes et 2 colonnes :\")\n", "printM(MatRand(3, 2))\n", "\n", "print(\"Matrice carrée au hasard à 4 lignes :\")\n", "printM(MatRand(4))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Opérations matricielles

\n", "\n", "
\n", "Définition
\n", "\n", "Soient $ M, N \\in \\mathcal{M}_{n,m}$ . Alors\n", "$ M\\pm N=(M_{i,j}\\pm N_{i,j})_{i,j}$ .\n", "\n", "
\n", "\n", "En d'autre terme pour additionner (ou soustraire) deux matrices on additionne (ou soustrait) coefficient par coefficient. Par exemple \n", "$$\n", "\\begin{pmatrix}\n", "1&2&3\\\\\n", "4&5&6\\\\\n", "7&8&9\\\\\n", "\\end{pmatrix}\n", "+\n", "\\begin{pmatrix}\n", "-1&0&1\\\\\n", "0&2&3\\\\\n", "-3&1&2\\\\\n", "\\end{pmatrix}\n", "=\n", "\\begin{pmatrix}\n", "0&2&4\\\\\n", "4&7&9\\\\\n", "4&9&11\\\\\n", "\\end{pmatrix}\n", "$$\n", "\n", "

Exercice papier

\n", "Soient \n", "$ A=\n", "\\begin{pmatrix}\n", "1&2\\\\\n", "3&4\n", "\\end{pmatrix}\n", "$ , \n", "$ B=\n", "\\begin{pmatrix}\n", "-1&0\\\\\n", "5&0\n", "\\end{pmatrix}\n", "$ , \n", "$ C=\n", "\\begin{pmatrix}\n", "-1&0&2\\\\\n", "1&2&3\\\\\n", "4&9&7\n", "\\end{pmatrix}\n", "$ , \n", "$ D=\n", "\\begin{pmatrix}\n", "12&99&11\\\\\n", "-2&2&22\\\\\n", "0&0&-1\n", "\\end{pmatrix}\n", "$ , \n", "$ E=\n", "\\begin{pmatrix}\n", "83&19&99\\\\\n", "2&2&-4\\\\\n", "1&1&-2\n", "\\end{pmatrix}\n", "$.
Réaliser les opérations $ A+B$ , $ A+C$, $ C+D$ , $ D-C$ , $ D-E$ , $ E+D$ et $ E-B$ .\n", "\n", "

Code

\n", "Ecrire les fonctions MatAdd et MatSous renvoyant l'addition et la soustraction de matrice. Avec ces fonctions, vérifiez vos calculs précédents." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def MatAdd(A, B) :\n", " return []" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def MatSous(A, B) :\n", " return []" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#Correction exercice\n", "A=[\n", " [1, 2],\n", " [3, 4]\n", "]\n", "B=[\n", " [-1, 0], \n", " [5, 0]\n", "]\n", "C=[\n", " [-1, 0, 2], \n", " [1, 2, 3], \n", " [4, 9, 7]\n", "]\n", "D=[\n", " [12, 99, 11], \n", " [-2, 2, 22], \n", " [0, 0, -1]\n", "]\n", "E=[\n", " [83, 19, 99], \n", " [2, 2, -4], \n", " [1, 1, -2]\n", "]\n", "\n", "print(\"A+B =\")\n", "printM(MatAdd(A, B))\n", "\n", "print(\"A+C =\")\n", "printM(MatAdd(A, C))\n", "\n", "print(\"C+D =\")\n", "printM(MatAdd(C, D))\n", "\n", "print(\"D-C =\")\n", "printM(MatSous(D, C))\n", "\n", "print(\"D-E =\")\n", "printM(MatSous(D, E))\n", "\n", "print(\"E+D =\")\n", "printM(MatAdd(E, D))\n", "\n", "print(\"E-B =\")\n", "printM(MatSous(E, B))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "Définition
\n", "\n", "Soient $ x\\in \\mathbb{R}$ et $ A\\in \\mathcal{M}_{n,m}$ alors\n", "$$xA=(xA_{i,j})_{i,j}$$\n", "\n", "
\n", "\n", "\n", "Une formule un peu pompeuse pour dire que multiplier une matrice par un nombre réel revient à multiplier chacun de ses coefficients par le nombre.\n", "\n", "

Code

\n", "Ecrire le code de cette opération" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def MatDilatation(x, A) :\n", " return []" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#Tests\n", "\n", "A=[\n", " [1, 2],\n", " [3, 4]\n", "]\n", "\n", "print(\"Le double de la matrice :\")\n", "printM(A)\n", "print(\"est la matrice :\")\n", "printM(MatDilatation(2, A))\n", "\n", "print(\"La moitié de la matrice :\")\n", "printM(A)\n", "print(\"est la matrice :\")\n", "printM(MatDilatation(1/2, A))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "Définition
\n", "\n", "Soient $ A\\in \\mathcal{M}_{n,m}$ et $ B\\in \\mathcal{M}_{m,p}$ . Alors $ A.B=C$ \n", "où $$C_{i,j}=\\sum_{k=1}^mA_{i,k}\\times B_{k,j}$$\n", "\n", "
\n", "\n", "\n", "Il faut prendre garde que le produit est bien possible : il faut que le nombre de colonne de la première soit égale au nombre de ligne de la seconde.\n", "\n", "Par exemple si $ A\n", "=\\begin{pmatrix}\n", "1&2&3\\\\\n", "-1&0&1\\\\\n", "0&2&-1\n", "\\end{pmatrix}\n", "$ \n", "et $ B=\n", "\\begin{pmatrix}\n", "0&2& 0\\\\\n", "-1& 2& 2\\\\\n", "0& 0& 3\n", "\\end{pmatrix}\n", "$ alors $ AB=\n", "\\begin{pmatrix}\n", "-2&6&13\\\\\n", "0&-2&3\\\\\n", "-2&4&1\n", "\\end{pmatrix}\n", "$ \n", "\n", "

Exercice papier

\n", "Réaliser les calculs suivants.\n", "\n", "
  1. \n", "$ \n", "\\begin{pmatrix}\n", "2&1\\\\\n", "1&-1\n", "\\end{pmatrix}\n", "\\times\n", "\\begin{pmatrix}\n", "1&-1\\\\\n", "1&2\n", "\\end{pmatrix}\n", "$ \n", "
  2. \n", "$ \n", "\\begin{pmatrix}\n", "2&1\\\\\n", "1&-1\n", "\\end{pmatrix}\n", "\\times\n", "\\begin{pmatrix}\n", "1&0&9\\\\\n", "3&2&1\n", "\\end{pmatrix}\n", "$ \n", "
  3. \n", "$ \n", "\\begin{pmatrix}\n", "2&1\\\\\n", "1&-1\n", "\\end{pmatrix}\n", "\\times\n", "\\begin{pmatrix}\n", "1&0&9\\\\\n", "3&2&1\\\\\n", "2&0&-1\n", "\\end{pmatrix}\n", "$ \n", "
  4. \n", "$ \n", "\\begin{pmatrix}\n", "2&1&0\\\\\n", "1&-1&1\n", "\\end{pmatrix}\n", "\\times\n", "\\begin{pmatrix}\n", "1&0&9\\\\\n", "3&2&1\\\\\n", "2&0&-1\n", "\\end{pmatrix}\n", "$ \n", "
  5. \n", "$ \n", "\\begin{pmatrix}\n", "2&1&0\\\\\n", "1&-1&1\\\\\n", "3&1&-1\n", "\\end{pmatrix}\n", "\\times\n", "\\begin{pmatrix}\n", "1&0&9\\\\\n", "3&2&1\\\\\n", "2&0&-1\n", "\\end{pmatrix}\n", "$ \n", "
\n", "\n", "

Code

\n", "Ecrire la fonction MatProd qui renvoie le produit des matrices passé en paramètre. Avec ces fonctions, vérifiez vos calculs précédents." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def MatProd(A, B) :\n", " return []" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#Correction exercice\n", "print(\"Question 1 :\")\n", "X=[\n", " [2, 1], \n", " [1, -1]\n", "]\n", "Y=[\n", " [1, -1], \n", " [1, 2]\n", "]\n", "printM(MatProd(X, Y))\n", "\n", "print(\"Question 2 :\")\n", "Y=[\n", " [1, 0, 9], \n", " [3, 2, 1]\n", "]\n", "printM(MatProd(X, Y))\n", "\n", "print(\"Question 3 :\")\n", "Y=[\n", " [1, 0, 9], \n", " [3, 2, 1], \n", " [2, 0, -1]\n", "]\n", "printM(MatProd(X, Y))\n", "\n", "print(\"Question 4 :\")\n", "X=[\n", " [2, 1, 0], \n", " [1, -1, 1]\n", "]\n", "printM(MatProd(X,Y))\n", "\n", "print(\"Question 5 :\")\n", "X=[\n", " [2, 1, 0], \n", " [1, -1, 1], \n", " [3, 1, -1]\n", "]\n", "printM(MatProd(X, Y))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "\n", "
\n", "Définition
\n", "\n", "On appel matrice identité, notée $ Id_n$ la matrice à coefficient tous nuls sauf ceux sur la diagonale qui valent $ 1$ : \n", "\n", "$$\n", "Id_n=\n", "\\begin{pmatrix}\n", "1&0&\\dots&0\\\\\n", "0&\\ddots&\\ddots&\\vdots\\\\\n", "\\vdots&\\ddots&\\ddots&0\\\\\n", "0&\\dots&0&1\n", "\\end{pmatrix}\n", "$$\n", "\n", "
\n", "\n", "\n", "La matrice identité équivaut au $ 1$ de l'ensemble des nombres réels. Précisément : \n", "\n", "\n", "
\n", "Proposition
\n", "\n", "Soit $ A\\in \\mathcal{M}_n$ alors $ AId_n=Id_nA=A$ .\n", "\n", "
\n", "\n", "

Code

\n", "Ecrire la fonction MatId(n) qui renvoie la matrice identité." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def MatId(n) : \n", " return []" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#Tests\n", "N=[2, 3, 10]\n", "for n in N : \n", " print(\"Matrice identité en dimension\", n)\n", " printM(MatId(n))\n", "\n", " \n", "A=[\n", " [1, 2],\n", " [3, 4]\n", "]\n", "print(\"Vérification de la proposition :\")\n", "printM(A)\n", "print(\"multipliée par l'identité donne\")\n", "printM(MatProd(A, MatId(len(A))))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "Définition
\n", "\n", "Soient $ A\\in \\mathcal{M}_{n, m}$ . On note $ ^t{A}$ la transposée de la matrice $ A$ définie par $ ( ^t{A})_{i,j}=A_{j,i}$ \n", "\n", "
\n", "\n", "\n", "En d'autre terme la transposée d'une matrice reviens à inverser lignes et colonnes. \n", "\n", "Par exemple $ \n", " ^t{\n", "\\begin{pmatrix}\n", "1&2&3\\\\\n", "9&0&4\\\\\n", "-1&1&1\n", "\\end{pmatrix}\n", "}\n", "=\n", "\\begin{pmatrix}\n", "1&9&-1\\\\\n", "2&0&1\\\\\n", "3&4&1\n", "\\end{pmatrix}\n", "$ \n", "\n", "

Code

\n", "Ecrire la fonction qui renvoie la transposé d'une matrice" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def MatTransp(A) :\n", " return []" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#Vérification\n", "M=[\n", " [1, 2, 3], \n", " [9, 0, 4], \n", " [-1, 1, 1]\n", "]\n", "print(\"La transposée de\")\n", "printM(M)\n", "print(\"est\")\n", "printM(MatTransp(M))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", " Déterminant\n", "
\n", "
\n", " Menu de navigation\n", " \n", "
\n", "\n", "A présent nous nous placerons toujours dans le cadre des matrices carrés de $ \\mathcal{M}_{n}$.\n", "\n", "
\n", "Définition
\n", "\n", "Soit $ A\\in \\mathcal{M}_{n}$. Le déterminant de la matrice $ A$ , noté $ \\det(A)$ , est le nombre réel défini par la formule : \n", "$$\\det(A)=\\sum_{\\sigma\\in \\mathfrak{S}_n}\\varepsilon(\\sigma)\\prod_{i=1}^nA_{i,\\sigma(i)}$$\n", "où $\\mathfrak{S}_n$ désigne le groupe symétrique d'ordre $ n$ (i.e. toutes les bijections de l'ensemble $ [\\![1 ; n]\\!]$ ) et $ \\varepsilon(\\sigma)$ la signature de la permutation $ \\sigma$ .\n", "\n", "
\n", "\n", "

Vous voyez flout, vous commencez à trembler et êtes témoin de votre inquiétude grandissante : \"Jusque là, ça allait ! J'arrivais à comprendre... Mais qu'est-ce qui se passe ? Qu'est-ce que c'est que ce charabia.\" Vous avez bien raison de trembler pauvre humain. Vous voilà confronté à une première définition térrifiante. Mais pas d'inquiétude sur ce que vous venez de lire... vous pouvez immédiatement l'oublier.

\n", "\n", "

Mais pourquoi avoir fait couler une goute de sueur froide le long de votre dos ? Déjà, parce que ça m'amuse beaucoup mais surtout pour vous montrer que cacher derrière ce que nous allons étudier se trouve une défintion térrifiante mais bien ficelée. Garder en tête que c'est LA définition de déterminant et \"OUI !\" s'il fallait vraiment l'étudier il faudrait qu'on parle de groupe symétrique et de signature. Mais dans le cadre de ce cours nous nous plaçons dans la pratique et dans la pratique, pas la peine de s'embeter avec cette affreuse définition.

" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Issue de la défintion on montre les propriétés suivantes. Nous verrons que dans la pratique elles sont tout à fait suffisantes.

\n", "\n", "
\n", "Proposition
\n", "\n", "Soit $ A\\in \\mathcal{M}_n$ . Notons $ C_1, \\dots, C_n$ les colonnes de la matrice $ A$ . En d'autre terme $ A=(C_1, \\dots, C_n)$ .\n", "
  1. Si on permute deux colonnes, le déterminant change de signe : \n", "$$\\det(\\dots,C_i,\\dots,C_j,\\dots)=\n", " -\\det(\\dots,C_j,\\dots,C_i,\\dots)\n", "$$\n", "
  2. On ne modifie par la valeur du déterminant en ajoutant à une colonne un multiple d'une autre colonne : \n", "$$\\det(\\dots,C_i,\\dots,C_j,\\dots)=\n", " \\det(\\dots,C_i+\\lambda C_j,\\dots,C_j,\\dots)\n", "$$\n", "
  3. Si on multiplie tous les coefficients d'une colonne par un réel $ x$ alors le déterminant est multiplier par $ x$ : \n", "$$\\det(\\dots,xC_i,\\dots)=x\\det(\\dots,C_i,\\dots)\n", "$$\n", "
  4. $ \\det(AB)=\\det(A)\\det(B)$ \n", "
  5. $ \\det({^t}A)=\\det(A)$ . En particulier toutes les règles ci-dessus s'applique en replaçant le mot \"colonne\" par le mot \"ligne\".\n", "
\n", "\n", "
\n", "\n", "\n", "

Exercice papier

\n", "En ne vous servant que des résultats de la proposition précédente déterminer :\n", "
  1. la valeur du déterminant d'une matrice avec deux colonnes identique,\n", "
  2. une formule pour $ \\det(xA)$ en fonction de $ \\det(A)$ .\n", "
" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#Ecrire en commentaire python (ou markdown si vous l'osez) les réponses aux deux questions précédentes.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Avant d'arriver au cas pratique du calcul du déterminant, armons-nous d'une petite définition

\n", "\n", "
\n", "Définition
\n", "\n", "Soient $ A\\in \\mathcal{M}_n$ et $ p$ et $ q$ deux entiers entre $ 1$ et $ n$ . Le mineur d'ordre $ p,q$ de la matrice $ A$ est la matrice notée $ \\widehat{A}_{p,q}\\in\\mathcal{M}_{n-1}$ correspondant à la matrice $ A$ où l'on a supprimé la ligne $ p$ et la colonne $ q$ . Précisément : \n", "\n", "$$\n", "(\\widehat{A}_{p,q})_{i,j}=\n", "\\left\\{\n", "\\begin{array}{rl}\n", "A_{i,j}&\\text{, si } i{<}p \\text{ et } j{<}q\\\\\n", "A_{i,j+1}&\\text{, si } i{<}p \\text{ et } j\\geqslant q\\\\\n", "A_{i+1,j}&\\text{, si } i\\geqslant p \\text{ et } j{<}q\\\\\n", "A_{i+1,j+1}&\\text{, si } i\\geqslant p \\text{ et } j\\geqslant q\n", "\\end{array}\n", "\\right.\n", "$$\n", "où $ i$ et $ j$ sont des nombres entiers entre $ 1$ et $ n-1$ .\n", "\n", "
\n", "\n", "\n", "Par exemple si $ A=\n", "\\begin{pmatrix}\n", "1&2&1\\\\\n", "2&0&1\\\\\n", "1&1&-1\n", "\\end{pmatrix}\n", "$ alors $ \\widehat{A}_{1, 2}=\n", "\\begin{pmatrix}\n", "2&1\\\\\n", "1&-1\n", "\\end{pmatrix}\n", "$ .\n", "\n", "

Code

\n", "Ecrire la fonction mineur(A, p, q) qui renvoie le mineur d'ordre $p$, $q$ de $A$" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def Mineur(A, p, q) :\n", " return []" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#Test\n", "\n", "M=[\n", " [1, 2, 1], \n", " [2, 0, 1], \n", " [1, 1, -1]\n", "]\n", "\n", "#Vous pouvez vous \"amusez\" à changer les valeurs de p et q pour vous assurez que votre code est bon\n", "p=0\n", "q=1\n", "\n", "print(\"Le mineur d'ordre (\", p+1, \", \", q+1, \") de la matrice \")\n", "printM(M)\n", "print(\"est la matrice\")\n", "printM(Mineur(M, p, q))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Voila LE théorème qui va nous permettre de calculer un déterminant

\n", "\n", "
\n", "Théorème
\n", "\n", "Si $ A\\in\\mathcal{M}_n$ pour $ n{>}1$ \n", "$$\\forall i\\in[\\![1 ; n]\\!], \\quad \\det(A)=\\sum_{j=1}^n(-1)^{i+j}A_{i,j}\\det(\\widehat{A}_{i,j})$$\n", "$$\\forall j\\in[\\![1 ; n]\\!], \\quad \\det(A)=\\sum_{i=1}^n(-1)^{i+j}A_{i,j}\\det(\\widehat{A}_{i,j})$$\n", "\n", "En particulier $ \\det\n", "\\begin{pmatrix}\n", "a&b\\\\\n", "c&d\n", "\\end{pmatrix}=ad-bc$ .\n", "\n", "Si $ A\\in \\mathcal{M}_1$ alors $ \\det(A)=A_{1,1}$ .\n", "\n", "
\n", "\n", "\n", "Application : \n", "calculons $ \\displaystyle{\\left|\n", "\\begin{array}{ccc}\n", "1&2&1\\\\\n", "2&0&1\\\\\n", "1&1&-1\n", "\\end{array}\n", "\\right|}$ (on remplace les parenthèses par des barres pour indiquer que nous calculons un déterminant).\n", "On choisi la colonne avec le plus de 0 pour minimiser les calculs. A savoir la colonne 2.\n", "\n", "$$\n", "\\left|\n", "\\begin{array}{ccc}\n", "1&2&1\\\\\n", "2&0&1\\\\\n", "1&1&-1\n", "\\end{array}\n", "\\right|=\n", "\\underbrace{\n", "-2\n", "\\left|\n", "\\begin{array}{ccc}\n", "2&1\\\\\n", "1&-1\n", "\\end{array}\n", "\\right|\n", "}_{=6}\n", "\\underbrace{\n", "+0\n", "\\left|\n", "\\begin{array}{ccc}\n", "1&1\\\\\n", "1&-1\n", "\\end{array}\n", "\\right|\n", "}_{=0}\n", "\\underbrace{\n", "-1\n", "\\left|\n", "\\begin{array}{ccc}\n", "1&1\\\\\n", "2&1\\\\\n", "\\end{array}\n", "\\right|\n", "}_{=1}\n", "=7\n", "$$\n", "\n", "\n", "Calculons à nouveau $ \\displaystyle{\\left|\n", "\\begin{array}{ccc}\n", "1&2&1\\\\\n", "2&0&1\\\\\n", "1&1&-1\n", "\\end{array}\n", "\\right|}$ . La première ligne ne change pas et nous allons l'utiliser pour faire apparaitre des $ 0$ sous le $ 1$ en haut à gauche. Pour cela nous allons soustraire à la seconde ligne deux fois la première et à la troisième une fois la première.\n", "$$\n", "\\left|\n", "\\begin{array}{ccc}\n", "1&2&1\\\\\n", "2&0&1\\\\\n", "1&1&-1\n", "\\end{array}\n", "\\right|\n", "=\n", "\\left|\n", "\\begin{array}{ccc}\n", "1&2&1\\\\\n", "0&-4&-1\\\\\n", "0&-1&-2\n", "\\end{array}\n", "\\right|\n", "=1\n", "\\left|\n", "\\begin{array}{cc}\n", "-4&-1\\\\\n", "-1&-2\n", "\\end{array}\n", "\\right|=7\n", "$$\n", "La seconde égalité c'est obtenue en développant le déterminant par rapport à la première colonne et la dernière égalité est le calcul des déterminants en dimension 2.\n", "\n", "

Exercice papier (ou pas)

\n", "Calculer les déterminants suivants : \n", "\n", "
  1. \n", "$ \\det\\begin{pmatrix}\n", "1&2\\\\\n", "8&16\n", "\\end{pmatrix}$ \n", "\n", "
  2. \n", "$ \\det\\begin{pmatrix}\n", "1&-2&0\\\\\n", "1&1&0\\\\\n", "199&22&7\n", "\\end{pmatrix}$ \n", "\n", "
  3. \n", "$ \\det\\begin{pmatrix}\n", "1&-2&3\\\\\n", "1&1&1\\\\\n", "2&2&2\n", "\\end{pmatrix}$ \n", "\n", "
  4. \n", "$ \\det\\begin{pmatrix}\n", "1&7&0\\\\\n", "1&0&1\\\\\n", "0&1&1\n", "\\end{pmatrix}$ \n", "\n", "
  5. \n", "$ \\det\\begin{pmatrix}\n", "1&-2&3\\\\\n", "1&2&1\\\\\n", "2&2&2\n", "\\end{pmatrix}$ \n", "\n", "
  6. \n", "$ \\det\\begin{pmatrix}\n", "1&0&0\\\\\n", "0&1&0\\\\\n", "0&0&1\n", "\\end{pmatrix}$ \n", "\n", "
  7. \n", "$ \\det\\begin{pmatrix}\n", "1&2&0&0\\\\\n", "2&1&2&0\\\\\n", "0&2&1&2\\\\\n", "0&0&2&1\n", "\\end{pmatrix}$ \n", "\n", "
  8. \n", "$ \\det\\begin{pmatrix}\n", "0&1&2&3\\\\\n", "1&2&3&0\\\\\n", "2&3&0&1\\\\\n", "3&0&1&2\n", "\\end{pmatrix}$ \n", "\n", "
    9. \n", "
  9. $ \\displaystyle{\n", "\\left|\n", "\\begin{array}{cc}\n", "cos(\\vartheta)&-sin(\\vartheta)\\\\\n", "sin(\\vartheta)&cos(\\vartheta)\n", "\\end{array}\n", "\\right|\n", "}$ \n", "
  10. $ \\displaystyle{\n", "\\left|\n", "\\begin{array}{ccc}\n", "1&1&1\\\\\n", "cos(a)&cos(b)&cos(c)\\\\\n", "sin(a)&sin(b)&sin(c)\n", "\\end{array}\n", "\\right|\n", "}$ \n", "
  11. $ \\displaystyle{\n", "\\left|\n", "\\begin{array}{ccc}\n", "\\lambda&1&1\\\\\n", "1&\\lambda&1\\\\\n", "1&1&\\lambda\n", "\\end{array}\n", "\\right|\n", "}$ \n", "\n", "
  12. $ \\displaystyle{\n", "\\left| \n", "\\begin{array}{ccc}\n", "1+a & a & a \\\\ \n", "b & 1+b & b \\\\ \n", "c & c & 1+c\n", "\\end{array}\n", "\\right| \n", "}$ \n", "\n", "
\n", "\n", "

Code

\n", "En vous servant de la formule récursive induite par le théorème, écrire la fonction det(A) renvoyant le déterminant de la matrice $A$." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def det(A) :\n", " return 0" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#Tests\n", "nombre_de_test=3\n", "for k in range(nombre_de_test) : \n", " M=MatRand(randint(2, 3)) #On tire au hasard une matrice carré de taille 2 ou 3\n", " print(\"Le déterminant de la matrice :\")\n", " printM(M)\n", " print(\"vaut\", det(M), end='\\n-----------------------------------------------------\\n')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", " Inverse matricielle\n", "
\n", "
\n", " Menu de navigation\n", " \n", "
\n", "Rappelons que nous cherchons à résoudre le système matricielle $ AX=B$ dont nous avons précédemment observé qu'une solution pourrait être $ X=A^{-1}B$. Nous en sommes donc à nous demander : qu'est-ce que $ A^{-1}$ ?. \n", "\n", "\n", "
\n", "Définition
\n", "\n", "On dira qu'une matrice $ A\\in \\mathcal{M}_n$ est inversible s'il existe une matrice $ B\\in \\mathcal{M}_n$ tel que $ AB=BA=Id_n$. Dans ce cas, la matrice $ B$ est appelé l'inverse de $ A$.\n", "\n", "
\n", "\n", "\n", "Il faut considérer l'inverse comme dans l'ensemble des nombres réels. L'inverse de $ 19$ est $ \\dfrac{1}{19}$ et ce nombre vérifie bien $ 19\\times\\dfrac{1}{19}=\\dfrac{1}{19}\\times 19=1$ (le \"$ 1$ \" de l'ensemble des matrices est la matrice identité).\n", "\n", "\n", "
\n", "Proposition
\n", "\n", "Soit $ A\\in \\mathcal{M}_n$ une matrice inversible. Son inverse est unique et est noté $ A^{-1}$ .\n", "\n", "
\n", "\n", "\n", "\n", "
\n", "

Démonstration

\n", "\n", "Soient $ B_1$ et $ B_2$ des inverses : $ B_1=B_1Id_n=B_1(AB_2)=(B_1A)B_2=Id_nB_2=B_2$ .\n", "\n", "
\n", "\n", "\n", "Déterminons une méthode de calcul pour inverser une matrice.\n", "\n", "\n", "
\n", "Définition
\n", "\n", "Soit $ A\\in \\mathcal{M}_n$ . La matrice des cofacteurs de $ A$ ou comatrice de $ A$ est la matrice, notée $ Co(A)$ définie pour tout $ i$ et $ j$ de $ [\\![1;n]\\!]$ par\n", "$$Co(A)_{i,j}=(-1)^{i+j}\\det(\\hat{A}_{i,j})$$\n", "où $ \\hat{A}_{i,j}$ est la matrice $ A$ où on a supprimé la ligne $ i$ et la colonne $ j$ .\n", "\n", "
\n", "\n", "\n", "Par exemple, \n", "$$Co\n", "\\begin{pmatrix}\n", "3&4&5\\\\\n", "-1&3&6\\\\\n", "3&4&-5\n", "\\end{pmatrix}=\n", "\\begin{pmatrix}\n", "-39&13&-13\\\\\n", "40&-30&0\\\\\n", "9&-23&13\n", "\\end{pmatrix}\n", "$$\n", "

Code

\n", "Ecrire la fonction MatCofact(A) qui renvoie la matrice des confacteurs de A." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def MatCofact(A) :\n", " return []" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#Test\n", "M=[\n", " [3, 4, 5], \n", " [-1, 3, 6], \n", " [3, 4, -5]\n", "]\n", "print(\"La matrice des confacteur de\")\n", "printM(M)\n", "print(\"est\")\n", "printM(MatCofact(M))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "
\n", "Théorème
\n", "\n", "Soit $ A\\in \\mathcal{M}_n$.\n", "
    \n", "
  1. La matrice $ A$ est inversible si et seulement si $ \\det(A)\\neq 0$.
    2. \n", "
  2. Si $ A$ est inversible alors $ A^{-1}=\\dfrac{1}{\\det(A)} ^t{Co(A)}$.
    3. \n", "
\n", "\n", "
\n", "\n", "\n", "\n", "
\n", "

Démonstration

\n", "\n", "Supposons que $ \\det(A)\\neq0$ et vérifions que $ A ^t{Co(A)}= ^t{Co(A)}A=\\det(A).Id_n$ . \n", "\n", "\n", "\\begin{eqnarray*}\n", "(A ^t{Co(A)})_{i,j} &=& \\sum_{k=1}^nA_{i,k} ^t(Co(A))_{k,j}\\\\\n", "&=& \\sum_{k=1}^nA_{i,k}Co(A)_{j,k}\\\\\n", "&=& \\sum_{k=1}^nA_{i,k}(-1)^{j+k}\\det(\\hat{A}_{j,k})\n", "\\end{eqnarray*}\n", "\n", "\n", "\n", "\n", "Si $ i=j$ alors cette dernière égalité correspond au déterminant d'après le calcul du déterminant par développement.\n", "\n", "Sinon, cette dernière ligne s'identifie à $ \\det(A')$ où $ A'$ est la même matrice que $ A$ sauf que la ligne $ j$ à été remplacée par la ligne $ i$ . Puisque $ i$ est différent de $ j$ , la matrice $ A'$ a deux lignes identiques ce qui implique que $ \\det(A')=0$ .\n", "\n", "\n", "
\n", "\n", "\n", "Par exemple\n", "$ \n", "\\begin{pmatrix}\n", "3&4&5\\\\\n", "-1&3&6\\\\\n", "3&4&-5\n", "\\end{pmatrix}^{-1}=\\dfrac{1}{-130}\n", " ^t{\n", "\\begin{pmatrix}\n", "-39&13&-13\\\\\n", "40&-30&0\\\\\n", "9&-23&13\n", "\\end{pmatrix}\n", "}\n", "=\\dfrac{1}{130}\n", "\\begin{pmatrix}\n", "39&-40&-9\\\\\n", "-13&30&23\\\\\n", "13&0&-13\n", "\\end{pmatrix}\n", "$ .\n", "En conclusion, pour savoir si un système, équivalent à l'équation matricielle $ AX=B$ possède une unique solution il faut et il suffit que $ \\det(A)$ soit non nul. En particulier on trouve la solution en réalisant le calcul $ A^{-1}B$ .\n", "\n", "\n", "

Code

\n", "Ecrire la fonction MatInv(A) qui renvoie, lorsque c'est possible, l'inverse de la matrice A." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def MatInv(A) :\n", " return []" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#Test 1\n", "M=[\n", " [3, 4, 5], \n", " [-1, 3, 6], \n", " [3, 4, -5]\n", "]\n", "print(\"L'inverse de\")\n", "printM(M)\n", "print(\"est\")\n", "printM(MatInv(M))\n", "\n", "#Test 2\n", "M=[\n", " [1, 2, 1],\n", " [1, 2, -1],\n", " [-2, -2, -1]]\n", "print(\"L'inverse de\")\n", "printM(M)\n", "print(\"est\")\n", "printM(MatInv(M))\n", "\n", "#Test 3\n", "M=[\n", " [1, 2, 1],\n", " [1, 2, -1],\n", " [2, 4, 0]\n", "]\n", "print(\"L'inverse de\")\n", "printM(M)\n", "print(\"est\")\n", "printM(MatInv(M))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "

Exercice papier

\n", "Soit $ A\\in \\mathcal{M}_n$ une matrice inversible. Déterminer une relation simple entre $ \\det(A)$ et $ \\det(A^{-1})$.\n", "\n", "

Exercice papier... et pas que

\n", "Pour chacune des matrices suivante, dire s'ils sont inversibles et si oui, donner son inverse ; dans ce cas vous pourrez vous auto-corriger en exécutant votre code.\n", "\n", "\n", "
  1. $ \n", "\\begin{pmatrix}\n", "a&b\\\\\n", "c&d\n", "\\end{pmatrix}\n", "$ \n", "\n", "
  2. $ \n", "\\begin{pmatrix}\n", "cos(\\vartheta)&-sin(\\vartheta)\\\\\n", "sin(\\vartheta)&cos(\\vartheta)\n", "\\end{pmatrix}\n", "$ \n", "\n", "
  3. $ \n", "\\begin{pmatrix}\n", "1&2&1\\\\\n", "1&2&-1\\\\\n", "-2&-2&-1\n", "\\end{pmatrix}\n", "$ \n", "\n", "
  4. $ \n", "\\begin{pmatrix}\n", "1&0&2\\\\\n", "0&-1&1\\\\\n", "1&-2&0\n", "\\end{pmatrix}\n", "$ \n", "\n", "
  5. $ \n", "\\begin{pmatrix}\n", "0&1&1&1\\\\\n", "1&0&1&1\\\\\n", "1&1&0&1\\\\\n", "1&1&1&0\n", "\\end{pmatrix}\n", "$ \n", "
  6. $ \n", "\\begin{pmatrix}\n", "0&1&1&1&1\\\\\n", "1&0&1&1&1\\\\\n", "1&1&0&1&1\\\\\n", "1&1&1&0&1\\\\\n", "1&1&1&1&0\n", "\\end{pmatrix}\n", "$ \n", "
  7. $ \n", "\\begin{pmatrix}\n", "0&1&1&1&1&1\\\\\n", "1&0&1&1&1&1\\\\\n", "1&1&0&1&1&1\\\\\n", "1&1&1&0&1&1\\\\\n", "1&1&1&1&0&1\\\\\n", "1&1&1&1&1&0\n", "\\end{pmatrix}\n", "$ \n", "
  8. $ \n", "\\begin{pmatrix}\n", "0&1&1&1&1&1&1\\\\\n", "1&0&1&1&1&1&1\\\\\n", "1&1&0&1&1&1&1\\\\\n", "1&1&1&0&1&1&1\\\\\n", "1&1&1&1&0&1&1\\\\\n", "1&1&1&1&1&0&1\\\\\n", "1&1&1&1&1&1&0\n", "\\end{pmatrix}\n", "$ \n", "
\n", "\n", "

Exercice papier... pas le choix

\n", "\n", "Discuter suivant les valeurs des paramètres ($ \\lambda$ , $ a$ et $ b$ ) des solutions éventuelles des système suivants : \n", "\n", "
  1. $ \\displaystyle{\n", "\\left\\{\n", "\\begin{array}{rcl}\n", "\\lambda x+y+z&=&1\\\\\n", "x+\\lambda y+z&=&1\\\\\n", "x+y+\\lambda z&=&1\n", "\\end{array}\n", "\\right.\n", "}$ \n", "
  2. $ \\displaystyle{\n", "\\left\\{\n", "\\begin{array}{rcl}\n", "ax+by+z&=&1\\\\\n", "x+aby+z&=&b\\\\\n", "x+by+az&=&1\n", "\\end{array}\n", "\\right.\n", "}$ \n", "
\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", " Pour se casser un peu la tête !\n", "
\n", "
\n", " Menu de navigation\n", " \n", "
\n", "\n", "\n", "Si tu es diligent et sage, ô étranger, calcule le nombre de têtes de bétail du troupeau du soleil qui autrefois paissait dans les champs de l'île de Thrinacian... .
\n", "\n", "Le dieu soleil (Hélios) possède un troupeau de taureaux et de vaches, dont une partie était blanche, une partie noire, une partie pie, et la quatrième jaune.
\n", "Pour les taureaux:\n", "\n", "Pour les vaches:\n", "\n", "" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "#Bon chance !" ] } ], "metadata": { "hide_input": false, "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.6.0" } }, "nbformat": 4, "nbformat_minor": 2 }