Mandelbrot_Complexe_correction.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <span style=\"color:#6C3483\">L'ensemble de Mandelbrot </span><span style=\"color:red\">(corrigé)</span>\n",
    "\n",
    "<span style=\"color:#6C3483\">Note : Cette activité <u>ne</u> nécessite <u>pas</u> la connaissance de l'écriture exponentielle d'un nombre complexe. </span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:#8E44AD\">Sommaire</span>\n",
    "\n",
    "<span style=\"color:#8E44AD\">0.</span> <a href=\"#0\">Définition de l'ensemble de Mandelbrot $\\mathcal{M}$</a><br>\n",
    "<span style=\"color:#8E44AD\">1.</span> <a href=\"#1\">Étude mathématique du cas $c=i$.</a><br>\n",
    "<span style=\"color:#8E44AD\">2.</span> <a href=\"#2\">Étude algorithmique du cas $c=1+i$.</a><br>\n",
    "<span style=\"color:#8E44AD\">3.</span> <a href=\"#3\">Étude dans le cas général et représentation graphique</a><br>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"color:#8E44AD\" id=\"0\">0. Définition de l'ensemble de Mandelbrot $\\mathcal{M}$.</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Pour tout $c \\in \\mathbb{C}$, on considère la suite de nombres complexes $(z_n)_{n \\geq 0}$ définie par :__\n",
    "<ul>\n",
    "    <li>$z_0=0$ ;</li>\n",
    "    <li>$\\forall n \\in \\mathbb{N}$ ; $\\displaystyle z_{n+1}=z_n^2+c$.</li>\n",
    "</ul>\n",
    "\n",
    "__et on pose :__<br><br>\n",
    "$\\forall n \\in \\mathbb{N}$ ; $r_n = \\lvert z_n \\rvert$.<br><br>\n",
    "<BLOCKQUOTE style='background-color:#DFF2FF;'>\n",
    "Pour chaque valeur de $c$, la suite $(r_n)_{n \\geq 0}$ est soit bornée soit non bornée.<br><br>\n",
    "    L'<strong>ensemble de Mandelbrot</strong> $\\mathcal{M}$ est l'ensemble des nombres complexes $c$ tels que la suite $(r_n)_{n \\geq 0}$ est bornée.\n",
    "</BLOCKQUOTE>    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"color:#8E44AD\" id=\"1\">1. Étude mathématique du cas $c=i$.</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Dans cette partie, on pose $c=i$.__<br><br>\n",
    "__1.1. Déterminer les formes algébriques des termes $z_1$, $z_2$ , $z_3$ et $z_4$.__<br><br>\n",
    "<span style=\"color:red\">$z_1=z_0^2+i=0^2+i=i$ <br> $z_2=z_1^2+i=i^2+i=-1+i$ <br> $z_3=z_2^2+i=(-1+i)^2+i=-i$ <br> $z_4=z_3^2+i=(-i)^2+i=-1+i$ </span><br>\n",
    "\n",
    "__1.2. Émettre une conjecture sur la valeur de $z_n$ suivant les valeurs de $n$, et démontrer cette conjecture.__<br><br>\n",
    "<span style=\"color:red\">Au vu des valeurs précédemment calculées, on peut conjecturer que $\\forall k \\geq 1$ ; $z_{2k}=-1+i\\;$  et $\\;z_{2k+1}=-i$, qui se démontre par une récurrence immédiate.</span><br>\n",
    "\n",
    "__1.3. $i$ appartient-il à l'ensemble $\\mathcal{M}$ de Mandelbrot ?__\n",
    "\n",
    "<span style=\"color:red\">D'après ce qui précède, la suite $(r_n)$ est bornée : $\\forall n \\in \\mathbb{N}$ ; $r_n = \\lvert z_n \\rvert \\leq \\text{max}( \\lvert i \\rvert;\\lvert -1+i \\rvert;\\lvert -i \\rvert ) =\\displaystyle\\frac{\\sqrt{2}}{2}$ et on en déduit donc que $i \\in \\mathcal{M}$</span><br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"color:#8E44AD\" id=\"2\">2. Étude algorithmique du cas $c=1+i$.</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Dans cette partie, on pose $c=1+i$.__<br><br>\n",
    "__2.1. En langage Python, le nombre complexe $i$ se code <mark>1j</mark> et la fonction <mark>abs</mark> permet de calculer le module d'un nombre complexe.__<br>\n",
    "$\\quad\\;\\;$__a. Exécuter les cellules suivantes. Que permettent-elles de calculer ?__\n",
    "<br><br><span style=\"color:red\">Les saisies permettent de calculer successivement $z_0$ ; $r_0$ ; $z_1$ et $r_1$.</span>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = 1+1j ; z0 = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "abs(z0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z1 = z0**2 +c\n",
    "z1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "abs(z1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\quad\\;\\;$__b. Effectuer des saisies pour calculer $z_2$ ; $z_3$, $r_2$ et $r_3$.__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Utiliser ces zones de saisie pour les calculs des termes\n",
    "z2 = z1**2+c\n",
    "z2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "z3 = z2**2+c\n",
    "z3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "abs(z2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "abs(z3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__2.2. On souhaite maintenant automatiser le calcul des termes de la suite $(z_n)_{n \\geq 0}$.__<br>\n",
    "$\\quad\\;$__a. Définir une fonction Python <mark>z</mark> qui reçoit en argument <mark>n</mark> et renvoie le nombre complexe $z_n$.__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Écrire ici la fonction Python z\n",
    "def z(n):\n",
    "    \"\"\"\n",
    "    Fonction qui calcule le terme de rang n de la suite (zn) pour c=1+i\n",
    "    \"\"\"\n",
    "    m = 0\n",
    "    c = 1+1j\n",
    "    for k in range(n):\n",
    "        m = m**2+c\n",
    "    return m"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\quad\\;$__b. Effectuer des appels à la fonction <mark>z</mark> pour retrouver les valeurs de $z_1$ ; $z_2$ et $z_3$.__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Utiliser ces zones de saisie pour les calculs des termes\n",
    "z(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\quad\\;$__c. À l'aide de la fonction Python <mark>z</mark>, déterminer $z_6$ puis $r_6$.__<br>\n",
    "$\\quad\\quad$__La suite $(r_n)_{n \\geq 0}$ semble-t-elle bornée?__<br>\n",
    "$\\quad\\quad$__$1+i$ semble-t-il appartenir à l'ensemble $\\mathcal{M}$ de Mandelbrot ?__\n",
    "<br><br><span style=\"color:red\">Au vu de la valeur de $r_6=\\lvert z_6 \\rvert$, on peut conjecturer que $1+i \\notin \\mathcal{M}$.</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Utiliser ces zones de saisie pour les calculs\n",
    "z(6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "abs(z(6))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"color:#8E44AD\" id=\"3\">3. Étude dans le cas général et représentation graphique</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Dans cette partie, on revient au cas général où $c \\in \\mathbb{C}$ est quelconque.__<br><br>\n",
    "__3.1. Redéfinir la fonction Python <mark>z</mark> (vue en 2.2.a) pour qu'elle reçoive en arguments <mark>n</mark> et <mark>c</mark> (dans cet ordre) et renvoie le nombre complexe $z_n$.__\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Écrire ici la fonction Python z\n",
    "def z(n,c):\n",
    "    \"\"\"\n",
    "    Fonction qui calcule le terme de rang n de la suite (zn)\n",
    "    \"\"\"\n",
    "    m = 0\n",
    "    for k in range(n):\n",
    "        m = m**2+c\n",
    "    return m"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Pour la suite, on <u>admettra</u> et on utilisera le résultat suivant :__\n",
    "\n",
    "<BLOCKQUOTE style='background-color:#DFF2FF;'>\n",
    "S'il existe un rang $N$ tel que $r_N>2$, alors la suite $(r_n)_{n \\geq 0}$ n'est pas bornée, et le nombre $c$ n'appartient alors pas à l'ensemble $\\mathcal{M}$ de Mandelbrot.\n",
    "</BLOCKQUOTE>    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__3.2. À l'aide de la fonction Python <mark>z</mark>, calculer $z_{10}$ puis $r_{10}$ dans le cas où $c=\\displaystyle\\frac{1+2i}{3}$.__<br>\n",
    "$\\quad\\;$__Le nombre $\\displaystyle\\frac{1+2i}{3}$ appartient-il à l'ensemble $\\mathcal{M}$ de Mandelbrot ?__\n",
    "<br><br><span style=\"color:red\">Comme $r_{10}=\\lvert z_{10} \\rvert >2$, on en déduit que $\\displaystyle\\frac{1+2i}{3} \\notin \\mathcal{M}$.</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Utiliser ces zones de saisie pour les calculs\n",
    "z(10,(1+2j)/3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "abs(z(10,(1+2j)/3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__3.3. Pour permettre de conjecturer si un nombre complexe $c$ appartient ou non à l'ensemble $\\mathcal{M}$ de Mandelbrot, on considère la fonction Python <mark>app_M</mark> donnée ci-dessous. Décrire la méthode expérimentale utilisée : Quel critère est appliqué ?__\n",
    "<br><br><span style=\"color:red\">L'algorithme teste si $\\lvert z_n \\rvert>2$ pour toutes les valeurs entières $n$ de $0$ à $29$. Dès qu'une de ces conditions est vérifiée, l'algorithme renvoie <mark>False</mark> qui signifie que $c \\notin \\mathcal{M}$. Dans le cas où aucune de ces conditions n'est vérifiée, on fait l'approximation que $c \\in \\mathcal{M}$ et l'algorithme renvoie <mark>True</mark>.</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def app_M(c,N=30):\n",
    "    \"\"\"\n",
    "    Fonction qui conjecture si c appartient à l'ensemble de Mandelbrot\n",
    "    \"\"\"\n",
    "    for n in range(N):\n",
    "        if abs(z(n,c))>2:\n",
    "            return False\n",
    "    \n",
    "    return True    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__3.4. Effectuer des appels à la fonction <mark>app_M</mark> pour conjecturer si les nombres $\\displaystyle\\frac{1}{2}$ ; $\\displaystyle\\frac{i}{2}$ et $\\displaystyle-\\frac{3+2i}{5}$ appartiennent à $\\mathcal{M}$.__ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Utiliser ces zones de saisie pour les appels à la fonction app_M\n",
    "app_M(1/2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "app_M(1j/2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "app_M(-(3+2j)/5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__3.5 Grâce à la fonction Python <mark>app_M</mark>, on peut approcher la représentation graphique de l'ensemble de Mandelbrot dans le plan complexe.__<br>\n",
    "$\\quad$__Exécuter la fonction <mark>graph_M</mark> donnée ci-dessous pour visualiser $\\mathcal{M}$ (patienter quelques instants pendant les calculs...).__\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#import des modules nécessaires\n",
    "from PIL import Image, ImageDraw\n",
    "\n",
    "def graph_M(app_M=app_M,profondeur=30,xmin=-2,xmax=1,ymin=-1,ymax=1,pix_unite=250,couleur_fond=(223,242,255),couleur_figure=(49,140,231),couleur_axes=(34,66,124),nom=\"Ensemble de Mandelbrot\"):\n",
    "    \"\"\"\n",
    "    REPRESENTATION GRAPHIQUE D'UN ENSEMBLE DE COMPLEXES\n",
    "    app_M: fonction booléenne qui indique si un complexe appartient à l'ensemble représenté\n",
    "    profondeur: profondeur de la recherche pour la fonction app_M\n",
    "    xmin, xmax, ymin, ymax : paramètres de réglage de la fenêtre de visualisation\n",
    "    pix_unite: nombre de pixels par unité\n",
    "    couleur_fond: couleur du fond\n",
    "    couleur_figure: couleur de l'ensemble représenté\n",
    "    couleur_axes: couleur des axes\n",
    "    nom: nom de l'ensemble représenté\n",
    "    \"\"\"\n",
    "    \n",
    "    # création du graphique\n",
    "    largeur=pix_unite*(xmax-xmin)+1 ; hauteur=pix_unite*(ymax-ymin)+1       \n",
    "    Graphique = Image.new('RGB', (largeur,hauteur), color = couleur_fond )           \n",
    "    Curseur = ImageDraw.Draw(Graphique)\n",
    "    \n",
    "    # tracé de l'ensemble M\n",
    "    for X in range(largeur):\n",
    "        for Y in range(hauteur):\n",
    "            # création des coordonnées mathématiques correspondant aux coordonnées de l'image\n",
    "            x,y = xmin+X*(xmax-xmin)/largeur,ymin+(hauteur-Y)*(ymax-ymin)/hauteur\n",
    "            # construction du complexe c\n",
    "            c = complex(x,y)\n",
    "            # coloration du point si c appartient à M\n",
    "            if app_M(c,N=profondeur): Curseur.point([X, Y], couleur_figure)\n",
    "\n",
    "    def conv_coord(x,y):\n",
    "        \"fonction qui convertit une coordonnée du repère mathématique en coordonnée sur l'image\"\n",
    "        return (x-xmin)*pix_unite,(y-ymin)*pix_unite,\n",
    "    \n",
    "    # tracé des axes\n",
    "    Curseur.line([conv_coord(xmin,0),conv_coord(xmax,0)],fill=couleur_axes)\n",
    "    Curseur.line([conv_coord(0,ymin),conv_coord(0,ymax)],fill=couleur_axes)\n",
    "    \n",
    "    # création des graduations annotées\n",
    "    for x in range(int(xmin),int(xmax)+1):\n",
    "        Curseur.line([conv_coord(x,-0.02),conv_coord(x,0.02)], fill=couleur_axes)    \n",
    "        Curseur.text(conv_coord(x+(-0.05 if x>=0 else 0.03),0.02),str(x),fill=couleur_axes)\n",
    "    for y in range(int(ymin),int(ymax)+1):\n",
    "        Curseur.line([conv_coord(-0.02,y),conv_coord(0.02,y)], fill=couleur_axes)    \n",
    "        Curseur.text(conv_coord(0.02,y+(-0.07 if y>=0 else 0.03)),str(-y),fill=couleur_axes)\n",
    "    \n",
    "    # écriture du titre / nom de la figure\n",
    "    Curseur.text((0,0),nom,fill=couleur_figure)\n",
    "        \n",
    "    return Graphique\n",
    "\n",
    "graph_M()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center> \n",
    "    ![Benoit_Mandelbrot](img/Benoit_Mandelbrot.jpg)\n",
    "    <a href=\"https://fr.wikipedia.org/wiki/Beno%C3%AEt_Mandelbrot\">Benoit Mandelbrot</a> (1924-2010) est considéré comme le découvreur des figures fractales, dont l'ensemble de Mandelbrot fait partie.\n",
    "</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"https://mybinder.org/v2/gh/mathauxandaines/TermMathExp.git/main?filepath=Julia_Complexe.ipynb\">\n",
    "</a>\n",
    "<span style=\"color:#6C3483\">  <br><br> $\\quad$ Pour aller plus loin: Voir l'activité sur les <a href=\"https://mybinder.org/v2/gh/mathauxandaines/TermMathExp.git/main?filepath=Julia_Complexe.ipynb\">ensembles de Julia</a>.\n",
    "</span>"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Raw Cell Format",
  "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.9.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}