Qu’est-ce qu’un attracteur

Les attracteurs
jeudi 14 janvier 2010
par  Dan Orsholits
popularité : 4%


Présentation théorique de l’attracteur

  1. Définition d’un attracteur
  2. Analogie d’un attracteur
  • Bref rappel concernant les transformations affines
  • Représentation graphique d’un attracteur grâce à un système de fonctions itérées
  • Conclusion

  • Sources
  • Annexes
  • Présentation théorique de l’attracteur

    Définition d’un attracteur

    Un attracteur est le résultat d’un système de fonctions itérées qui est évalué plusieurs fois, idéalement une infinité de fois. L’attracteur représente en quelque sorte la limite de ce système après un très grand nombre d’itérations, c’est-à-dire qu’après un certain nombre d’itérations, disons 1 million, nous ne verrons presque, ou même, aucune différence entre la millionième itération et la milliardième itération du système ; c’est le théorème de Hutchinson. Ce théorème stipule que si chaque fonction est contractante (c’est-à-dire que deux point $x$ et $y$ se rapprochent invariablement vers un point fixe), alors on obtient un attracteur, et cet attracteur est unique. Cela implique que chaque système de fonctions itérées qui est composé de fonctions contractantes ne peut avoir qu’un attracteur unique. Dans notre cas pour illustrer ce qu’est un attracteur nous allons prendre trois points quelconques et leur appliquer des transformations affines qui sont les fonctions qui constitueront le système de fonctions itérées. Pour rendre plus claire cette définition, nous pouvons faire une analogie qui explique la manière dont l’attracteur est obtenu à partir d’un système de fonctions itérées.

    Analogie d’un attracteur

    Prenons un photocopieur qui possède plusieurs systèmes optiques, disons 3. Ces systèmes optiques représentent trois transformations affines différentes. Puis on met une image ou figure initiale et on la photocopie. Après nous nous retrouvons avec 3 photocopies toutes transformées et réduites. L’obtention de ces 3 copies à partir d’une image est la première itération de notre système. Pour faire la deuxième itération, nous reprenons nos 3 photocopies qui ont été faites à l’issue de la première itération et nous les photocopions. Nous nous retrouvons avec 9 photocopies qui sont le résultat de la deuxième itération et le processus se répète. Lorsqu’un grand nombre d’itérations sont effectuées, nous remarquons que les images obtenues ne changent pas, c’est l’attracteur du système, soit l’attracteur du photocopieur.

    Comment établir une transformation affine
    Pour établir chaque fonction nous devons prendre six points quelconques, 3 points correspondant à l’image initiale et 3 points correspondant à l’image transformée désirée. Prenons une figure simple, comme un triangle :

    le triangle initial et le triangle transformé

    Le triangle de gauche est le triangle initial et le triangle de droite est l’image transformée. Maintenant pour établir nos transformations nous devons utiliser l’équation générale des transformations affines qui est, sous forme matricielle :

    $\left( \begin{array}{c} u \\ v \end{array} \right)=\left( \begin{array}{cc} a & b \\ c & d \end{array} \right)\left( \begin{array}{c} x \\ y \end{array} \right)+\left( \begin{array}{c} e \\ f \end{array} \right)$

    et sous forme linéaire :

    $u=ax+by+e$

    $v=cx+dy+f$

    Dans ces équations $ u $ représente la coordonnée $ x $ du point transformé (un des points du triangle vert) et $ v $ représente la coordonnée $ y $ du point transformé. Donc pour trouver les coefficients $ a,b,c,d,e,f $ nous devons résoudre un système d’équations avec six inconnues et par conséquent six équations qui est le suivant :

    $\left\{ \begin{array}{c} u_1={ax}_1+{by}_1+e \\ v_1={cx}_1+{dy}_1+f \\ u_2={ax}_2+{by}_2+e \\ v_2={cx}_2+{dy}_2+f \\ u_3={ax}_3+{by}_3+e \\ v_3={cx}_3+{dy}_3+f \end{array} \right.$
    «  »
    Puis nous résolvons ce système, soit à la main, soit avec Mathematica ce qui est beaucoup plus simple. Pour résoudre le système avec Mathematica, il suffit de copier le code ;

    et ensuite de l’évaluer. Ensuite pour trouver nos transformations on substitue les $x, y, u$ et $z$ par les coordonnées de nos points.

    Si nous reprenons la figure avec les deux triangles, nous pouvons trouver les coefficients qui nous permettent de transformer le triangle rouge en le triangle vert. Le code à utiliser dans Mathematica est le suivant :

    et on obtient comme coefficients :

    Maintenant nous devons les réécrire ces coefficients d’une manière différente pour qu’ils puissent être évalués avec le module IteratedMappings et cela rend plus simple aussi la méthode qui consiste à attribuer une transformation sur un point quelconque avec des probabilités différentes ;

    Finalement appliquons cette transformation au triangle rouge pour obtenir un triangle violet identique au triangle vert :

    et le code :

    Comment établir et évaluer un système de fonctions itérées

    Il y plusieurs méthodes pour évaluer un système de fonctions itérées dans Mathematica mais il faut avoir au moins 3 transformations affines différentes si l’on veut obtenir un attracteur. Nous pouvons utiliser la module IteratedMappings (qui doit être téléchargée) ou nous pouvons utiliser une autre méthode qui consiste à appliquer une transformation au hasard avec des probabilités différentes. Cette méthode est la plus performante parce qu’elle nous permet d’approcher l’attracteur sans avoir une quantité trop importante de données contrairement à l’utilisation de la module IteratedMappings. Toutefois, avec la deuxième méthode, on a parfois besoin de faire un grand nombre d’itérations si l’on veut se rapprocher de l’attracteur. C’est celle qui je détaillerai, mais vous pouvez trouver en annexe un fichier Mathematica qui utilise le module IteratedMappings pour obtenir l’attracteur.

    D’abord il faut que nous choisissions quelles transformations vont composer le système de fonctions itérées. Pour cet exemple j’ai choisi des transformations affines qui donnent un flocon de neige qui sont les suivantes :

    D’abord j’utiliserai la méthode qui ne nécessite pas la module IteratedMappings. Donc ayant déjà défini nos transformations, il faut définir les fonctions des transformations affines à appliquer sur un point quelconque :

    Ensuite, nous devons établir notre système de fonctions itérées. Pour cela nous utilisons la commande NestList. Si on prend comme fonction $x+1$ en itérant avec NestList 4 fois,

    on obtient

    Nous voyons que la commande NestList applique la fonction à elle-même 4 fois. Le résultat de la quatrième itération est la fonction $f$ qui est appliquée à elle-même quatre fois et ces quatre itérations de $f$ sont appliquées à $1+x$. En d’autres mots, pour reprendre l’analogie du photocopieur, NestList a commencé avec $1+x$ puis lui a appliqué une transformation. Ensuite NestList a photocopié la première itération et puis la deuxième et enfin la troisième pour obtenir la quatrième itération.

    Maintenant définissons notre système de fonctions itérées :

    La fonction sta sert à simplifier le code en établissant une fonction qui tire au hasard une des transformations à chaque itération pour l’appliquer sur un point quelconque. Maintenant pour montrer qu’il faut plusieurs itérations pour obtenir l’attracteur nous allons comparer deux images, la première obtenue après 10’000 itérations et la deuxième obtenue après 1’000’000 d’itérations et la dernière après 3’000’000 d’itérations :

    flocon de neige après 10'000 itérations
    flocon de neige après 1'000'000 d'itérations
    flocon de neige après 3'000'000 d'itérations

    On peut remarquer que plus on effectue d’itérations, plus il y a de points dans le flocon. Par contre après un certain nombre d’itérations la densité de points sur l’image sera tellement élevée que nous ne verrons aucune différence même si nous itérions de nouveau la fonction. La raison pour cela est que l’écran d’un ordinateur ne peut pas afficher plus de points qu’il a de pixels, mais toutefois ces points supplémentaires seront calculés par Mathematica (et qui occuperont une grande quantité de mémoire vive de l’ordinateur !).

    Conclusion

    Dans cet article j’ai détaillé une façon d’obtenir un attracteur, ici une image à partir de quatre transformations. Mais, l’attracteur ne sert pas uniquement à faire de petites images comme des flocons de neige. Il sert également à décrire des comportements qui nous semblent chaotiques mais qui suivent un itinéraire précis. Nous pouvons prendre par exemple l’attracteur de Lorenz qui représente le comportement de la convection de l’atmosphère. C’est aussi Lorenz qui a montré que le chaos dépend fortement des conditions initiales. En 1961, Lorenz simulait une prévision météorologique et pour une des données il a omis quelques décimales. Il constate après avoir effectué la simulation qu’il a obtenu des conditions météorologiques totalement différentes. Cette découverte donne naissance à "l’effet papillon", qui illustre l’effet possible des battements d’ailes d’un papillon sur l’évolution de la météo.

     [1]

    Les attracteurs sont aussi utilisés par la théorie du chaos pour décrire des comportements dans des multitudes de domaines comme la météorologie, la robotique, la physique, la démographie etc. C’est grâce aux attracteurs qu’on peut observer le chaos parce que l’attracteur nous permet de visualiser des comportement non-linéaires qui ont, en fait un comportement invariable après une certaine quantité de temps.

    Sources :

    Annexes :

    - Fichier Mathematica avec les figures de l’article
    - Le module IteratedMappings [2]
    - Encore plus de transformations affines pour faire d’autres figures


    [1L’attracteur de Lorenz

    [2Pour utiliser ce module ouvrez-le et évaluez tout le contenu du fichier dans Mathematica


    Commentaires  forum ferme

    Logo de Loïc Reymond
    lundi 18 janvier 2010 à 22h24 - par  Loïc Reymond

    Il s’agit seulement d’une faute de frappe, un "t" manquant à "NestList" !
    Il est vrai que je n’ai pas précisé de quoi il s’agissait, excusez-moi.

    Bonne soirée !

    Logo de Bernard Vuilleumier
    lundi 18 janvier 2010 à 22h20 - par  Bernard Vuilleumier

    Quel est l’intérêt de ce commentaire ? Que voulez-vous signaler, proposer ?

    Logo de Loïc Reymond
    lundi 18 janvier 2010 à 22h09 - par  Loïc Reymond

    " Nous voyons que la commande NestList applique la fonction à elle-même 4 fois "

    Logo de Loïc Reymond
    dimanche 17 janvier 2010 à 12h55 - par  Loïc Reymond

    Bonjour,

    il me semble qu’il reste quelques fautes d’orthographe dans cet article :

    " [...] et trois points [...] "
    " [...] du point transformé [...] " 2 x
    " [...] système d’équations [...] qui est le suivant : "
    " [...] à attribuer [...] "
    " [...] sur un (?) point quelconque [...] "
    " [...] cette transformation [...] "
    " [...] nous pouvons utiliser le module [...] "
    " [...] qui doit être téléchargé [...] "
    " [...] du module IteratedMapping [...] " 2 x

    Article très clair par ailleurs !