{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Premiers pas dans Sage Math\n",
    "\n",
    "L'objectif de ce cours est de présenter des outils et des structures de données classiques pour intéragir avec le système de calcul formel Sage."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " ## Trouver de l'aide\n",
    " \n",
    " Pour trouver de l'aide, il suffit de taper le nom mathématique de l'objet que vous souhaitez utiliser (en utilisant une majuscule) suivi d'un point d'intérogation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "Permutations?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si vous ne connaissez pas le nom de la fonction mathématique, vous pouvez le deviner en écrivant les premières lettre puis en tapant sur la touche tabulation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "Permu<TAB>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vous pouvez aussi voir le code source d'un programme en mettant deux points d'interrogation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "Permutations??"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " - On peut trouver de nombreux tutoriels dans la page Help de l'interface jupyter. Il y a des tutoriels et une API complète des objets disponibles.\n",
    "\n",
    " - Essayer de trouver un tutoriel de programmation Python, un tutoriel pour utiliser l'algèbre linéaire, un tutoriel pour utiliser les fonctions symétriques, et l'API des arbres binaires.\n",
    " \n",
    "### Référence\n",
    " \n",
    "  A. Casamayou, N. Théry et al. *Calcul mathématique avec Sage*. 2013."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Les polynômes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " - Racine d'un polynôme\n",
    " \n",
    " Chercher dans la documentation comment écrire un polynôme, puis définissez le polynôme\n",
    " $$\n",
    " P = x^3- 3.x^2 + 1.\n",
    " $$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "P = x^3 - 3* x^2  + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dessiner ce polynôme, avec la fonction plot sur l'intervalle $[1,3]$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "plot(P, [-1,3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Determiner les racines de ce polynômes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "roots = P.roots(); roots"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Que remarquez-vous ? Trouvez-vous le résultat normal ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "numerical_approx( roots[0][0].imag() )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il est aussi possible de trouvez des valeurs approchée des racine lorsque l'on précise \n",
    "l'intervalle où chercher la racine. Chercher la fonction qui permet de le faire et déterminer un valeur approchée des\n",
    "trois racines en spécifiant les trois intervals."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "P.find_root(-1,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "P.find_root(0,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "P.find_root(1,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " - polynôme à plusieurs variables\n",
    "\n",
    "Trouver dans la documentation la façon de définir l'anneau des polynômes $R$ à deux variables $y$ et $t$, dont les coefficients sont dans les rationels $\\mathbb{Q}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "R.<y,t> = QQ[]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "R"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Définissez le polynôme $Q = y^2 - 1 - 2.t + t^3$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "Q = y^2-1-2*t+t^3; Q"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Affichez-le en 3 dimensions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "plot3d(Q, (y,0,3),(t,0,3), plot_points=10)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " - interpolation polynômiale\n",
    " \n",
    " Trouvez le polynôme qui passe par les points suivant : $[1,2]$, $[3,2]$, $[-1,-1]$ et $[4,3]$.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "R1.<x> = QQ[]; R1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "R1.lagrange_polynomial( [(1,2), (3,2), (-1,-1), (4,3)] )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " - Factorisation des polynômes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Calcul Matriciel\n",
    "\n",
    "- Inverse de matrice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cherchez dans la documentation comment définir une matrice ) coefficient dans les rationels. Et définissez la matrice :\n",
    "$$\n",
    "M = \n",
    "\\left(\n",
    "\\begin{array}{ccc}\n",
    "2 & 4 & 1 \\\\\n",
    "8 & 9 & 2 \\\\ \n",
    "3 & 7 & 3\n",
    "\\end{array}\n",
    "\\right)\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "M = Matrix(QQ,[[2,4,1],[8,9,2],[3,7,3]]); M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Faites la même chose mais dans l'anneau symbolique."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "M=Matrix(SR,[[2,4,1],[8,9,2],[3,7,3]]); M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vérifiez qu'elle est inversible en calculant son determinant: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "M.det()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calculez maintenant l'inverse de cette matrice : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "M^(-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " - Noyau\n",
    " \n",
    " Définissez maintenant la matrice suivante :\n",
    " $$\n",
    " N = \\left( \n",
    " \\begin{array}{ccc}\n",
    " 1 & 2 & 3 \\\\\n",
    " 4 & 5 & 6 \\\\\n",
    " 7 & 8 & 9\n",
    " \\end{array}\n",
    " \\right)\n",
    " $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "N=Matrix(QQ,[[1,2,3],[4,5,6],[7,8,9]]); N"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Déterminer le noyeau de la matrice :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "N.kernel()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Récupérer les vecteurs de la base."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "N.kernel().basis()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " - Solution d'équation linéaire\n",
    " \n",
    "Cherchez maintenant comment déterminer la/les solution de l'équation linéaire suivante : \n",
    " $$\n",
    " \\left(\\begin{array}{rrr}\n",
    "2 & 4 & 1 \\\\\n",
    "8 & 9 & 2 \\\\\n",
    "3 & 7 & 3\n",
    "\\end{array}\\right) \\times x = \n",
    "\\left(\\begin{array}{r}\n",
    "2 \\\\\n",
    "2 \\\\\n",
    "1\n",
    "\\end{array}\\right)\n",
    " $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "M^(-1)*vector([2,2,1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " - Diagonalisation d'une matrice\n",
    " \n",
    " Soit M la matrice :\n",
    "$$\n",
    " M=\n",
    " \\left(\\begin{array}{rrr}\n",
    "0 & 1 & 3 \\\\\n",
    "1 & -1 & 0 \\\\\n",
    "1 & 0 & 1\n",
    "\\end{array}\\right)\n",
    "$$\n",
    " \n",
    " \n",
    " \n",
    " Trouver comment diagonaliser $M$ en fournissant ses matrices de passages ainsi que sa matrice diagonale."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "M = Matrix(SR,[[0,1,3],[1,-1,0],[1,0,1]]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "D,P = M.eigenmatrix_left()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "P^(-1)*D*P == M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " - Ecriture sous forme de Jordan\n",
    " \n",
    "Soit la matrice $M=\n",
    "\\left(\\begin{array}{rrr}\n",
    "5 & 1 & -1 \\\\\n",
    "-1 & 7 & -4 \\\\\n",
    "0 & 0 & 3\n",
    "\\end{array}\\right)\n",
    "$.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "M = Matrix(QQ, [(5, 1, -1), (-1, 7, -4), (0, 0, 3)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si la matrice P est diagonalisable, on peut utiliser eignematrix() pour calculer la matricie diagonale.\n",
    "Sinon, il ne faut pas le faire !\n",
    "\n",
    "Essayer de diagonaliser la matrice $M$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "T,P = M.eigenmatrix_right()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Afficher la matrice la matrice de passage. Que remarquez-vous ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0 1 0]\n",
       "[1 1 0]\n",
       "[1 0 0]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "P"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ici, on voit que la matrice de passage n'est pas inversible. Ce qui facheux pour une matrice de passage.\n",
    "En fait M n'est pas diagonalisable et il ne fallait pas utiliser eigenmatrix_left().\n",
    "\n",
    "En fait, il faut mettre la matrice dans la forme de Jordan. Cherchez la fonction qui met M sous la forme de Jordan\n",
    "et donnez les matrice de passage."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3|0 0]\n",
       "[-+---]\n",
       "[0|6 1]\n",
       "[0|0 6]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "J,P = M.jordan_form(transformation=True); J"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ 0 -1  1]\n",
       "[ 1 -1  0]\n",
       "[ 1  0  0]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "P"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vérifiez que vous avez bien obtenu la forme de Jordan."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "P * J * P^(-1) == M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercice :** Calculer M^11"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D = Matrix(QQ, 3, 3, lambda i,j: J.diagonal()[i] if i==j else 0 )\n",
    "N = J-D\n",
    "P*( D^11 + 11*D^10*N )*P^(-1) == M^11"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dérivation et intégration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " - Soient les fonctions suivantes : $$sin(x)$$ \n",
    " $$fx^3+x-1$$\n",
    " $$\\ln(x^4-3)$$ \n",
    " Cherchez dans la documentation comment dériver une fonction, puis calculez la première dérivé des trois fonctions précédentes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " - Calculez la troisième dérivée des fonctions précédentes :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " - Calculez la fonction intégrale de \n",
    "    $$\n",
    "    \\int x\\sin(x^3)dx\n",
    "    $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " - et l'intégrale de :\n",
    " $$\n",
    " \\int_0^1 \\frac{x}{x^2+1} dx\n",
    " $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Equations différentielles\n",
    "\n",
    "## Commandes de base\n",
    "\n",
    " -On commence par définir une variable t et une fonction x dépendant de cette variable :\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "t = var('t')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = function('x')(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On utilise ensuite :\n",
    "\n",
    "desolve(equation,variable,ics=...,ivar=...,show_method=..., contrib_ode=...) Où :\n",
    "\n",
    " – equation est l’équation différentielle. L’égalité est symbolisée par ==. Par exemple l’équation x 0 = 2x + t s’écrit diff(x,t)==2*x+t ;\n",
    "\n",
    " – variable est le nom de la variable dépendante, c’est-à-dire la fonction x dans x 0 = 2x + t;\n",
    "\n",
    " – ics est un argument optionnel qui permet d’entrer des conditions initiales. Pour une équation du premier ordre, on entre une liste [t0,x0], pour les équations du second ordre c’est [t0,x0,t1,x1] ou [t0,x0,x 0 0 ] ;\n",
    "\n",
    " – ivar est un argument optionnel qui permet de préciser la variable indépendante, c’est-à-dire t dans x 0 = 2x + t. Cet argument doit absolument être précisé en cas d’équations dépendant de paramètres comme par exemple x 0 = ax + bt + c ;\n",
    "\n",
    " – show_method est un argument optionnel fixé à False par défaut. Dans le cas contraire, il demande à Sage de préciser la méthode de résolution utilisée. Les termes anglais renvoyés sont linear, separable, exact, homogeneous, bernoulli, generalized homogeneous. Sage renvoie alors une liste dont le premier argument est la solution et le deuxième la méthode ;\n",
    "\n",
    " – contrib_ode est un argument optionnel par défaut fixé à False. Dans le cas contraire, desolve pourra s’occuper des équations de Ricatti, Lagrange, Clairaut et d’autres cas pathologiques."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Par exemple, prenons l'equation différentielle du 1er ordre:\n",
    "\n",
    "$$y'+ 3y = e^x$$ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1/4*(4*_C + e^(4*t))*e^(-3*t), 'linear']"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "desolve(diff(x,t)+3*x==exp(t),x,show_method=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " - Vous pouvez obtenir la solution particulière vérifiant y(0) = 1 avec la commande :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1/4*(e^(4*t) + 3)*e^(-3*t)"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "desolve(diff(x,t)+3*x==exp(t),x(t),ics=[0,1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " **Exercice :** "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " - Résolvez l'equation différentielle du 1er ordre suivante:\n",
    " $$\n",
    " y'-2y/(x-1)=(x+1)^3\n",
    " $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " - Sachant que la dérivée seconde de la fonction x par rapport à t s'obtenant avec *diff(x,t,2)*, résolvez léquation du second ordre linéaire à coefficients constants, suivante :\n",
    " $$\n",
    " y\"+3y=t^2-7t+31\n",
    " $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Théorie des graphes\n",
    "\n",
    " - Digraphes\n",
    " \n",
    " Chercher comment définir le graphe dons les sommets sont $V = \\{0, 1, 2, 3, 4\\}$ et les arcs sont $E = \\{ (0,1), (0,2), (0,3), (1,0), (2,4) \\}$.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "g = DiGraph({0:[1,2,3], 1: [0], 2:[4]}); g"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " - Plus cours chemin\n",
    "\n",
    "Déterminer le plus court chemin allant de 1 à 4."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "g.shortest_path(1,4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Combinatoire"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " - produit cartesien\n",
    " \n",
    " Cherchez dans la doucmentation comment définir le produit cartésient suivant :\n",
    " $$\n",
    " \\{3,4,5\\} \\times \\{6,7,8\\} \\times \\{ 3 \\}\n",
    " $$\n",
    "\n",
    "Listez l'élément de ce produit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "list( cartesian_product( [range(3,6), range(6,9), range(3,4)] ) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " - Sous-ensemble\n",
    " \n",
    " De même listez tous les sous-ensemble de \\{1,2,3\\}."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "list( Subsets( [1,2,3] ) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Listez maintenant les sous-ensemble de taille de de $\\{1, 2, 3 \\}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "list( Subsets( [1,2,3], 2 ) )"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "SageMath 7.3",
   "language": "",
   "name": "sagemath"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}