Gravitation

Bonjour à tous,

On parlait (là) de faire une simulation numérique de la gravitation pour simuler le mouvement de Rosetta. Je proposais (ici) une méthode. Je l'ai fait.

Caractéristiques techniques

• Langage : Python2/3.
• Dépendances : Scipy, Numpy et Matplotlib.
• Limitation : Résolution des EDO par la méthode d'Euler, qui est non stable !
• Licence : zlib, donc libre sans viralité. (ce n'est pas précisé dans les fichier d'ailleurs !)

Ça marche, c'est-à-dire qu'en donnant des valeurs réels pour le système Terre-Soleil, ça donne le bon résultat. C'est très limité, car le système est très sensible aux conditions initiales (et j'en ai bavé à cause de cela !), le tout avec une méthode pas stable… La version avec scipy.integrate.odeint devrait venir sous peu, mais comme je maitrise mal, je voulais avoir un truc qui marche avant (et comme ça marche, je le présente).

Utilisation

Le script s'utilise comme suit :

1

python(3|2) gravite.py test.json

Commentaires

Le fonctionnement interne est le suivant : la classe ObjetCeleste (fichier ObCe) contient un objet du système solaire avec son nom, sa masse, ses conditions initiales de position et vitesse et deux booléens attracteur/attiré (avec un seul "t" dans le code ! Yeah l'orthographe ! ) pour limiter les calculs (le soleil est fixe, les comètes n'attirent rien). Le tout est initialisé avec un fichier json lut par parseur (fichier json_parser). Le fichier gravite fait l'affichage et la résolution du système. La dérivation du système se fait dans la classe ObjetCeleste MAIS devra se faire dans une fonction annexe quand on passera à scipy.integrate.odeint. Le code est relativement bien commenté (sans vérification orthographique cependant). Aucune gestion des exception.

Du code de physicien. Mais du bon code de physiscien : l'entrée est via la console, et le nombre d'objet n'est pas défini dans le corps du programme. J'ai déjà fait bien pire…

Le code

Je rappelle : la méthode n'est pas stable et le système est très sensible aux conditions initiales. Les 4 fichiers sont ci-dessous :

ObCe.py

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

#!/usr/bin/env python3
# -*-coding:Utf-8 -*

"""
Définit la classe ObjetCeleste qui represente un objet dans le système solaire.
"""

#Python2 special import.
from __future__ import (division, absolute_import, with_statement,
                        print_function, unicode_literals)

#Scientific import.
import numpy as np
import scipy as sp

class ObjetCeleste:
    """
    Définit un objet céléste par : 
    - ses coordonnées en espace ; (couple de flottant)
    - ses coordonnées en vitesse ; (couple de flottant)
    - son nom ; (chaine de caractère)
    - sa masse ; (flottant)
    - comment il se comporte vis-à-vis des autres. (couple de booléen)
    Possède les fonctions résolvant les équations différentiels du mouvement.
    """
    def __init__(self, nom, masse, pos, vit, comportement):
        """Initialisation simple de l'objet."""
        self.nom = nom
        self.pos = np.array(pos)
        self.vit = np.array(vit)
        self.masse = masse
        self.attracteur, self.atire = comportement #Atiré

    def gravite(self, objet):
        """Renvoie l'accélération dû à l'attraction d'un autre corps."""
        G = 6.67e-11
        module_acc = -G*objet.masse / sum((self.pos-objet.pos)**2)
        #array : carré terme à terme.

        #On projete dans le plan. Pour cela, on calcule l'angle theta entre objet.pos/self.pos et l'axe des X pris en self.pos.
        #Passage par l'arctan est le quart de cercle.
        arctan = sp.arctan( (objet.pos[1]-self.pos[1]) / (objet.pos[0]-self.pos[0]) )
        if (arctan > 0 and self.pos[1] > 0) or (arctan < 0 and self.pos[1] < 0):
            #Cas facile : artan donne la bonne valeur de theta entre -pi/2 et pi/2 dans le demi-cercle droit.
            theta = arctan
        else:
            #Demi-cercle gauche ; atan va de -pi/2 (|y|>>|x|, y>0) à pi/2 (|y|>>|x|, y<0),
            #avec x<0 sur tout le demi-cercle et atan~0 pour |x|>>|y|.
            #D'où theta = atan + pi. Theta ira de -pi/2 à 3pi/2 sur tout le cercle.
            theta = arctan + sp.pi
        ##DEBUG print(sum((self.pos-objet.pos)**2))
        acc_x = module_acc * sp.cos(theta)
        acc_y = module_acc * sp.sin(theta)
        return np.array([acc_x, acc_y])

    def __str__(self):
         """Affichage."""
         return self.nom+", actuellement en " + str(self.pos) + " va à la vitesse " + str(self.vit) + \
             ". Sa masse est " + str(self.masse) + \
                 ". Est-il attracteur-attiré ? " + str(bool(self.attracteur)) + "," + str(bool(self.atire)) + "."

    def resout(self, objets_celestes, dt):
        """Résout les équations différentiels du mouvement et mets à jour position et vitesse.
        objets_celestes est la liste de tout les objets céléstes présents."""
        acc = np.array([0.,0.])
        if self.atire:
            for oc in objets_celestes:
                if oc.attracteur and oc is not self:
                    res = self.gravite(oc)
                    acc[0] += res[0]
                    acc[1] += res[1]
                    ##DEBUG print(res)
            self.pos += self.vit*dt
            self.vit += acc*dt

gravite.py

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

#!/usr/bin/env python3
# -*-coding:Utf-8 -*

"""
Entree-sortie.
"""

#Python2 special import.
from __future__ import (division, absolute_import, with_statement,
                        print_function, unicode_literals)

import sys

import numpy as np
import scipy as sp
import matplotlib.pyplot as plt

from json_parser import parseur

#TRY
fichier = sys.argv[1]
#Objets célèste est la liste de tous les objets, avec leur position initiales.
objets_celestes = parseur(fichier)

##DEBUG print(objets_celestes[0], objets_celestes[1])
T = 10000 ; dt = 1e4

#Memoire stoque les position et vitesses des objets.
memoire = np.zeros((T, 4*len(objets_celestes)))
for i, objet in enumerate(objets_celestes):
    memoire[0, 4*i] = objet.pos[0] ; memoire[0, 4*i+1] = objet.pos[1]
    memoire[0, 4*i+2] = objet.vit[0] ; memoire[0, 4*i+3] = objet.vit[1]


for t in range(1,T):
    for i,objet in enumerate(objets_celestes):
        objet.resout(objets_celestes, dt)
    for i, objet in enumerate(objets_celestes):
        memoire[t, 4*i] = objet.pos[0] ; memoire[t, 4*i+1] = objet.pos[1]
        memoire[t, 4*i+2] = objet.vit[0] ; memoire[t, 4*i+3] = objet.vit[1]

##DEBUG print(memoire)
plt.plot(memoire[:,0],memoire[:,1])
plt.show()

json_parser.py

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

#!/usr/bin/env python3
# -*-coding:Utf-8 -*

"""
Contient la fonction parseur qui lit un fichier json et le convertit en objet python.
"""

#Python2 special import.
from __future__ import (division, absolute_import, with_statement,
                        print_function, unicode_literals)

import json

from ObCe import ObjetCeleste

def parseur(fichier):
    """
    Renvoie une liste d'objet céléstes correctement formaté en lisant le fichier json
    'fichier' (chaine de caractère).
    """
    with open(fichier) as fich:
        json_decode = json.load(fich) #Un petit try serai bien ici.
    objets_celestes = []
    for objet in json_decode:
        objet_celeste = ObjetCeleste(nom=objet['nom'], masse=objet['masse'],\
                                     pos=objet['pos'], vit=objet['vit'],\
                                     comportement=objet['bool'])
        objets_celestes.append(objet_celeste)
    return objets_celestes

test.json

1
2
3
4

[
{"nom":"planete", "pos":[0.00001,1e11], "vit":[30e3,0.0], "masse":6e24, "bool":[0, 1]},
{"nom":"etoile", "pos":[0,0], "vit":[0,0], "masse":1e30, "bool":[1, 0]}
]

Je reste dans le coin (pas ce soir, dodo) pour les questions, et proposez une version stable d'ici quelques temps.

Bonne soirée !

edit Arius : ajout du tag CdS

J'avais commencé à faire quelque chose de similaire sur JSFiddle, avec quelques différences. Par exemple, je considerais toujours le problème comme étant planaire (ce qui est vrai pour un système à deux corps comme celui que tu présentes), ce qui m'évite le besoin d'une projection. C'est moins vrai quand on commence à considérer plus de deux objets, mais il est toujours possible de changer les équations si je les écris de manière suffisamment généraliste.

J'avais bloqué (mais je prévois de m'y remettre la semaine prochaine) sur les conditions initiales (qui ont l'air de t'avoir posé des problèmes aussi), mais il est probablement possible d'en parler pour trouver une solution idéale. Mon idée était de dŕiver une expression de l'accélèration et de la vitesse qui permettent une orbite pour une position, une masse et peut-être aussi une direction donnée. Ça devrait intuitivement toujours être possible de trouver quelque chose. Ça permettrait un peu de flexibilité, et d'espérer un jour avoir une interface graphique comme ils ont au Kennedy Space center, en Floride. Tu as une idée ( ou une démonstration mathématique) sur comment faire?

Il y a aussi un problème avec ta fonction "resout". Tu intègres la vitesse pour obtenir la position comme si c'était une constante du temps, mais tu trouves la vitesse en intégrant l'accélèration en fonction du temps. Du coup ça n'est pas correct.

Tu devrais avoir

v=v0+a*dt

x=x0+v0dt+adt*dt/2 (tu n'as pas le /2 dans tes formules)

Je ne comprends pas trop ce que tu veux dire par "résolution des EDO". Je ne vois rien qui ne puisse être fait analytiquement (en gardant à l'esprit qu'il est tard, et qu'il est possible que je ne sois pas totalement sobre). Tu pourrais élaborer?

Une raison pour faire commencer le temps à 10000?

Une autre addition sympa serait que si une planète passe trop près d'une étoile, elle soit absorbée, et la même chose avec un astéroïde près d'une planète. Si tu as d'autres idées, je suis preneur.

En tout cas, je pense que cette idée de déplacements infinitésimaux est meilleure et plus facile à adapter pour un système avec beaucoup d'objets que l'introduction directe des lois de Kepler. Belle initiative que cette implémentation.

Tu devrais avoir v=v0+adt x=x0+v0dt+adtdt/2 (tu n'as pas le /2 dans tes formules)

j'affirme que $a dt << v_0$, donc le néglige joyeusement. Les équations que j'utilise pour trouver une solution sont une méthode "direct" :

$$\frac{dx}{dt} = \frac{x(t+dt)-x(t)}{dt} \Rightarrow x(t+dt) = x(t) + \frac{dx}{dt} dt$$

Cette méthode marche, est très simple à implémenter mais est non stable : l’énergie n'est pas conservé, et au bout de quelques tours, ce qui devrait être un cercle devient une ellipse.

C'est ça, justement, ma résolution des EDO. Une résolution numérique. Des gens ont implémentés des méthodes beaucoup plus efficaces (stables, plus rapides…), comme la méthode de Runge-Kutta, mais comme je ne savais pas si mon erreur venait de l'utilisation de la fonction ou d'autre chose, j'ai vite-fait implémenter une méthode d'Euler.

Une raison pour faire commencer le temps à 10000 ?

1
2

T = 10000 
for t in range(1,T):

Le temps ne commence pas à 10000, mais va de 1 à 10000. Si tu parles de "memoire = np.zeros((T, 4*len(objets_celestes)))", ça initialise juste un vecteur avec la bonne taille.

Une autre addition sympa serait que si une planète passe trop près d'une étoile, elle soit absorbée, et la même chose avec un astéroïde près d'une planète. Si tu as d'autres idées, je suis preneur.

C'est déjà le cas de fait : si la vitesse d'un corps n'est pas assez fort, il se retrouve sur l'étoile et la force gravitationnelle va le bloquer. De plus, étant donné les échelles de taille, on peut légitimement considérer que tout les corps sont ponctuels.

J'avais bloqué sur les conditions initiales

J'ai pris celle de la Terre et du soleil, en unité SI. Et malgré ça, j'ai réussi à me planter.

Mon idée était de dŕiver une expression de l'accélèration et de la vitesse qui permettent une orbite pour une position, une masse et peut-être aussi une direction donnée. Ça devrait intuitivement toujours être possible de trouver quelque chose. Ça permettrait un peu de flexibilité, et d'espérer un jour avoir une interface graphique comme ils ont au Kennedy Space center, en Floride. Tu as une idée ( ou une démonstration mathématique) sur comment faire?

Je doute que ce soit possible. Le système à trois corps n'est pas soluble analytiquement (sauf traitement perturbatif), donc avec les corps soleil/Terre/Jupiter, le mouvement de ta comète est chaotique : une légère variation des conditions initiales va donner un système avec une trajectoire très différente. En toute honnêteté, je ne sais pas comment ils font dans les centres spatiaux (leur satellite a des moyens de propulsions, ça doit aider).

Mais la stabilité d'une méthode comme ça a été débattue et travaillée pas mal, notamment dans le cadre de la dynamique des molécules. En gros, le pas de temps doit être suffisamment petit, et en introduisant des paramètres de mélange adaptés, on peut l'agrandir un peu.

Les autres méthodes (comme RK4) sont plus stables et probablement plus rapides, mais j'ai des doutes dès lors que de très nombreux corps sont présents. Probablement pas un problème dans le cas d'un démonstrateur pour ZdS par contre, je pense qu'on peut le faire de manière très satisfaisante dans les deux cas.

Je n'ai pas encore le temps de regarder tout ça aujourd'hui, mais j'espère pouvoir le faire cette semaine

La stabilité de la méthode d'Euler explicite, c'est pas forcément gagné d'avance dans un cas non-linéaire comme ici. Il y a aussi de fortes chances qu'il faille modifier le pas de temps à chaque itération.

RK4 sera pas forcément plus stable qu'Euler (sauf erreur de ma part, il n'y a même à priori aucune raison qu'elle le soit, c'est juste du Euler à plus grand ordre de précision), par contre elle sera nécessairement plus lente (plus de calculs, tout simplement).

Si j'ai du temps, j'essaierai de pondre un petit quelque chose dans la semaine.

La stabilité de la méthode d'Euler explicite, c'est pas forcément gagné d'avance dans un cas non-linéaire comme ici.

Je tiens à confirmer, c'est pas stable (avec les paramètres mis dans le fichier, le cercle part en vrille dès le 1er tour ).

RK4 sera pas forcément plus stable qu'Euler (sauf erreur de ma part, il n'y a même à priori aucune raison qu'elle le soit, c'est juste du Euler à plus grand ordre de précision), par contre elle sera nécessairement plus lente (plus de calculs, tout simplement).

J'ai vu ça vite fait il y 2 ans, donc je préfère ne pas m'avancer. De toute façon, il n'est pas question de programmer moi-même un RK4 alors que d'autre ont fait des fonctions de résolution d'EDO qui marchent ! Il faut juste que j'arrive à utiliser odeint (scipy.interate) correctement.

Vraiment, faire soit-même la résolution, à part pour avoir un truc qui marche à montrer, ce n'est pas DU TOUT le bon plan.

Mais la stabilité d'une méthode comme ça a été débattue et travaillée pas mal, notamment dans le cadre de la dynamique des molécules.

Je ne pense pas qu'on fasse du Euler avec de la dynamique moléculaire. On fait plutôt du Verlet ou du Nose-Hoover (pour la stabilité entre autre, justement) (un cours sur la simulation numérique, si quelqu'un a mieux/autre chose, je suis preneur).

Je tiens à confirmer, c'est pas stable (avec les paramètres mis dans le fichier, le cercle part en vrille dès le 1er tour ).

C'est pas parce que ça ne fait pas physiquement ce que tu veux que ça fasse que c'est numériquement instable. Ce sont deux notions complètement différentes.

J'ai vu ça vite fait il y 2 ans, donc je préfère ne pas m'avancer. De toute façon, il n'est pas question de programmer moi-même un RK4 alors que d'autre ont fait des fonctions de résolution d'EDO qui marchent ! Il faut juste que j'arrive à utiliser odeint (scipy.interate) correctement.

Je n'ai jamais dit qu'il fallait coder soi-même RK4, ce serait stupide. Surtout que ce n'est pas ça qui réglera le problème de l'instabilité physique du système, ce dernier est non-linéaire et super-sensible aux conditions initiales. C'est d'ailleurs à mon avis l'un des principaux intérêts d'une telle simulation : voir que même avec deux corps, le problème des mouvements des corps est physiquement instable.

Tu as entièrement raison, sur les deux points. Cependant (je peux ajouter un cependant ? ), le pas de temps change la taille du pseudo-cercle de la simulation, donc j'ai de bonnes raisons de penser que c'est un problème numérique.

Il me vient une question existentielle : pour deux corps, le système est soluble analytiquement et, à ma connaissance, non chaotique (ellipse, effondrement ou "fuite", pas de solutions bizarres, bref, du Kepler !). Dès trois, la question ne se pose plus, c'est chaotique, instable et tout le tintouin. D'où : comment qualifier correctement un système à deux corps régie uniquement par la gravitation de l'un sur l'autre ?

Je comprends pas bien la question …

Qu'est-ce que tu entends par "qualifier" ? Donner les données pertinentes ?

J'ai écrit au-dessus pas mal de fois le mot « stable », sans jamais le définir correctement. À deux corps, c'est déterministe, sensible aux conditions initiales (je crois…), mais pas chaotique. Dès trois, c'est toujours déterministe, mais tellement sensible aux conditions initiales que ça en devient chaotique. Je me demande donc comment nommer correctement le système à deux corps qui est stable mais pas trop.

La stabilité, je crois pas avoir vu de définition universelle … Cela dépend surement de l'étude. Ici on pourrait le définir par le biais de la distance entre deux flots aux conditions initiales proches, si cette distance est petite on pourrait parler de stabilité aux petites perturbations. À confirmer par un physicien … mais moi je l'entends comme ça.

Pas trop d'accord parce que si je prends des orbites denses mais tout à fait régulières (par exemple une rotation d'angle irrationnel sur un cercle ou sur un tore si tu veux du temps continu), il n'y a rien de dynamiquement compliqué mais on ne revient jamais sur ses pas…

Pas trop d'accord parce que si je prends des orbites denses mais tout à fait régulières (par exemple une rotation d'angle irrationnel sur un cercle ou sur un tore si tu veux du temps continu), il n'y a rien de dynamiquement compliqué mais on ne revient jamais sur ses pas…

Je ne comprends pas du tout ce que tu essaies de dire. Ça veut dire quoi "une rotation d'angle irrationnel sur un cercle" ? Si tu tournes de $2\pi$, c'est irrationnel et tu reviens sur tes pas. Par ailleurs, si tu tournes tout le temps sur le même cercle, tu peux t'amuser à découper mathématiquement ta trajectoire en parts irrationnelles de tour, ça n’empêchera pas le fait que le mouvement est parfaitement régulier. Enfin, la notion de chaos n'a rien à voir avec le fait que le système soit "dynamique compliqué" (termes qui restent à être définis…).

Ah oui c'est vrai que c'est trompeur comme expression. J'entends par angle irrationnel un angle qui n'est pas sous la forme $p\pi/q$ avec $p,q$ des entiers.

Ça peut être régulier sans que le mouvement se répète, ou alors on a pas les mêmes définitions …

Plutôt qu'Euler explicite, utilise au minimum Euler semi-implicite : il est aussi du premier ordre, mais est un peu plus stable et a la bonne idée d'être symplectique (i.e., de garantir à peu près la conservation de l'énergie), pour un coût de calcul identique. Pour avoir Euler semi-implicite, il suffit juste d'inverser tes deux lignes suivantes :

1
2

            self.pos += self.vit*dt
            self.vit += acc*dt

Tu peux aussi utiliser d'autres schémas symplectiques qui ont un ordre supérieur ainsi que pour la conservation de l'énergie, comme le schéma leapfrog. Par contre, Runge-Kutta explicite n'a pas grand intérêt ici, puisque non symplectique.

La notion de chaotique a au contraire tout à voir avec la sensibilité aux conditions initiales. Pour des conditions initiales véritablement identiques, un système chaotique déterministe évoluera exactement de la même manière à chaque fois ; c'est justement parce que l'on ne parvient pas à obtenir des conditions initiales parfaitement exactes qu'il est difficile de prévoir le comportement des systèmes chaotiques.

La notion de chaotique a au contraire tout à voir avec la sensibilité aux conditions initiales. Pour des conditions initiales véritablement identiques, un système chaotique déterministe évoluera exactement de la même manière à chaque fois ; c'est justement parce que l'on ne parvient pas à obtenir des conditions initiales parfaitement exactes qu'il est difficile de prévoir le comportement des systèmes chaotiques.

Ça ne change rien au fait que la définition de ce qu'est un système chaotique n'est pas seulement lié à sa sensibilité aux conditions initiales. Cette sensibilité n'est même qu'une conséquence du caractère chaotique du système. En effet, si on prend le système régie par l'équation $\dot x=x$, il est fortement sensible aux conditions initiales (on peut même dire que des états voisins vont diverger de façon exponentielle l'un de l'autre). Pourtant, ce système n'est pas chaotique parce qu'il possède une sorte de "point fixe" attracteur à l'infini. Ce qui n'est pas compatible avec la notion de comportement apériodique à long-terme d'un système chaotique.

En fait, est-ce que tu veux bien nous définir "le chaos" ?

Parce que pour moi $\dot{x} = x$ n'est pas sensible aux conditions initiales. Il faut "juste" passer dans une autre carte locale au voisinage de l'infini (au sens compactifié d'Alexandrov). D'ailleurs c'est exactement un point fixe attractif en ce sens.

En fait, est-ce que tu veux bien nous définir "le chaos" ?

C'est pas super-simple ni consensuel, mais je dirais qu'il y a deux ingrédients essentiels : système complètement déterminé, et apériodicité du comportement à long terme. Le fait que deux états voisins divergent de façon exponentielle n'étant de mon point de vue qu'une conséquence des deux points précédents (même si historiquement, c'est ce genre d'observations qui a conduit à l'élaboration des théories qui tournent autour de l'étude du chaos).

Le fait que $\dot x=x$ possède un point fixe attracteur empêche de le considérer comme étant chaotique. Ça ne l'empêche pas d'être fortement sensible aux conditions initiales. Si on prend deux états voisins $E_1$ et $E_2$ séparés par $\delta E$, la distance entre les deux états va varier selon $\dot{\delta E}=\delta E$, soit $\delta E=\delta E_0 e^t$. On a exactement le cas d'états voisins qui divergent de façon exponentielle l'un de l'autre, c'est exactement la définition d'une grande sensibilité aux conditions initiales.

Ce que tu dis est intéressant. Je suis par contre pas vraiment d'accord sur ta deuxième partie. Certes, les deux orbites s'éloignent au sens de ta distance de manière exponentielle. Maintenant si on étudie leurs orbites sur le compactifié d'Alexandrov (qui donne une topologie et un sens à l'infini), ces deux orbites convergent vers la même limite (et à même vitesse).

Donc ils sont voisins … et le restent à l'infini !

En revanche, si on prend par exemple l'application $$f : x \mapsto x - \frac{x^2 + 1}{2x}$$ définie sur $\mathbf{C}$, les points selon leur position à la droite réelle ont un comportement totalement différents. Ceux qui ont une partie imaginaire strictement positive tendent vers $i$, ceux qui en ont une strictement négative vers $-i$ et les autres … on sait pas trop.

Là on a trois comportements très différents pour des conditions initiales aussi proches que l'on veut. Ça c'est pour moi un comportement chaotique.

J'avais mal interprété ta deuxième phrase : je pensais que tu affirmais qu'un système chaotique n'était pas déterministe.

Pour la première phrase, je maintiens que tu te trompes. La sensibilité aux conditions initiales, au sens de la théorie du chaos, est une condition nécessaire pour qu'un système soit chaotique, et donc, tous les systèmes chaotiques sont sensibles aux conditions initiales. Mais je suis d'accord avec toi sur le fait que ce ne soit pas une condition suffisante.

Il se peut que cette condition d'apériodicité du comportement à long terme soit équivalente à celle de sensibilité aux conditions initiales (complétée par les autres conditions nécessaires).