D'après wikipedia...

Présentation

Le modèle mathématique de la percolation a été introduit par John Hammersley en 1957. Il s'intéresse aux caractéristiques des milieux aléatoires, plus précisément aux ensembles de sommets connectés dans un graphe aléatoire.

Imaginons que l'on place de l'eau au sommet d'une pierre spongieuse. S'il y a assez de petits canaux, il est alors possible qu'il y ait un chemin du centre de la pierre vers l'extérieur. Ce modèle permet de répondre à ce genre de question.

Description du modèle de base

Nous considérons le réseau d-dimensionnel $Z^d$ : les sommets sont des couples de points à distance 1.

Nous fixons ensuite un paramètre p compris entre 0 et 1. Chaque arête est alors :

• ouverte avec probabilité p (on l'enlève, en d'autres termes)
• fermée avec probabilité 1-p (on la garde),

ceci indépendamment les unes des autres.

On note Pp la mesure obtenue.

On s'intéresse à l'existence d'un chemin infini dans le graphe aléatoire ainsi obtenu. Une quantité essentielle est la probabilité de percolation : $\theta(p)=P_p(O\rightarrow\infty)$. Par des arguments de couplage, il est aisé de démontrer que θ est une fonction croissante de p.

Il existe un point critique pc tel que θ(p) est nulle si p < pc et strictement positive si p > pc. En dimension deux, Harry Kesten a démontré qu'on a pc = 1 / 2.

Les différents régimes

Le régime sous-critique p < pc

Dans ce régime, il n'y a pas de chemin infini dans le graphe. Les composantes connexes (appelé aussi amas) finis sont généralement de petite taille. Plus précisément la probabilité que l'amas contenant le point x ait une taille qui dépasse n décroît exponentiellement vite avec n. En particulier, la taille moyenne d'un amas est finie.

Le régime critique p = pc

Ce régime est encore mal connu (à l'exception notable de la dimension 2). On conjecture que θ(pc) = 0, c’est-à-dire qu'il n'y a pas de percolation au point critique, mais ceci n'est pour l'instant démontré qu'en dimension deux ou en grande dimension d > 18.

En particulier, le cas de la dimension trois, dont la pertinence physique est évidente, demeure non prouvé.

Le régime sur-critique p > pc

Dans la phase surcritique, il y a une unique composante infinie de points connectés. Cependant, les amas finis sont généralement de petite taille.

L'amas infini rencontre tout l'espace; plus précisément la proportion de points d'une boîte de taille n qui appartiennent à l'amas infini tend vers θ(pc) > 0 lorsque n tend vers l'infini.

On sait aussi que l'amas infini est très rugueux : la proportion des points d'une boîte de taille n qui sont à la frontière de l'amas infini parmi la totalité des points de l'amas infini qui sont dans cette boîte tend vers 1 − p lorsque n tend vers l'infini.

La propagation des feux de forêts

Présentation

On considère une forêt, dont la distribution des arbres est aléatoire et obéit à une certaine densité d.

On constate expérimentalement que la propagation d'un feu de forêt dépend de d :

• en-dessous d'une valeur critique, il ne se passe rien,
• au-dessus, le feu se propage.

On reconnaît un phénomène de percolation, que l'on va chercher à modéliser.

Modélisation

On assimile la forêt à $\mathbb{Z}^2$ (réseau infini régulier à deux dimensions).

Percolation de site

On autorise la propagation de proche en proche, uniquement par faces adjacentes : on s'oriente donc ici vers une percolation de site.

On modélise cette propagation d'un feu de forêt par un automate cellulaire...

On dresse un tableau de taille $n \times n$ (notre forêt), que l'on remplit aléatoirement d'arbres, selon une densité $d \in [0,1]$ fixée.

Chaque case peut prendre 4 états :

• 0 : pas d'arbre,
• 1 : un arbre intacte,
• 2 : un arbre en feu,
• 3 : un arbre brûlé.

La règle d'évolution de notre automate cellulaire est alors : pour chaque case (i,j) en feu,

• si les cases adjacentes (haut, bas, droite, gauche) sont des arbres intactes, on les change en arbre en feu,
• puis on considère la case (i,j) comme brûlée.

On s'intéresse alors au problème suivant : En mettant le feu dans l'arbre supérieur gauche, quelle est la probabilité, fonction de la densité, que l'arbre inférieur droit prenne feu ?

Percolation de liens

Le code

  #-*- coding:utf8 -*-
  from numpy import zeros
  from random import randint
  from Tkinter import *

  class FeuForet(Frame):
      ' ' ' Code des couleurs :
           - 0 : sans arbre,
           - 1 : arbre,
           - 2 : arbre en feu,
           - 3 : arbre brûlé.' ' '

      _couleur = {0:'white', 1:'green', 2:'red', 3: 'black'}
      _n = 32

      def __init__(self, taille = 512, densite = 0.6, temps = 300):
          self._n = taille
          self._foret = zeros((self._n,self._n))
          Frame.__init__(self)
          self.pack()
          self._can = Canvas(self,bg='white',height=512,width=512)
          self._can.pack()
          for k in range(int(densite*taille*taille)):
              self._foret[randint(0,self._n-1),randint(0,self._n-1)]=1
          self.representeForet()
          self.miseAFeu()
          for k in range(temps):
              self.representeForet()
              self.miseAJour()


      def miseAFeu(self):
          self._foret[0,0]=2


      def miseAJour(self):
          ' ' 'Cette méthode contient la règle d'évolution de l'automate cellulaire.
             La règle est simple : si une cellule est en feu, alors :
                  - elle communique le feu à la cellule du haut, du bas, de la droite et de la   gauche,
                  - elle s'éteint.
             Bien sûr, il faut faire attention aux bords.' ' '

          matrice = zeros((self._n,self._n))
          for k in range(self._n):
              for l in range(self._n):
                  if self._foret[k,l] == 2:
                      matrice[k,l] = 3
                      for (m,p) in ((k-1,l),(k+1,l),(k,l+1),(k,l-1)):
                          if m in (-1,self._n) or p in (-1,self._n):
                              pass
                          elif self._foret[m,p] == 1:
                              matrice[m,p] = 2
                  elif matrice[k,l]==0:
                      matrice[k,l] = self._foret[k,l]
          self._foret = matrice


      def representeForet(self):
          for k in range(self._n):
              for l in range(self._n):
                  self._can.create_rectangle(k*512/self._n,l*512/self._n,(k+1)*512/self._n,(l+1)*512/ self._n,fill=self._couleur[self._foret[k,l]])
          self.update()



  if __name__ == _main_:
      FeuForet(taille = 512, densite = 0.8, temps = 300).mainloop()