1. Suite de Thue-Morse
Programme Python pour la générer :
>>> m, t = 1, [0]

2. >>> while m != 2**16 :
... n=0
... while n != m :
... r=(int(t[n])-1)**2
... t.append(r)
... n=n+1
... m=m*2
Tracés avec Turtle Graphics :
a = 0
while a < 2**16 :
if t[a] == 0 :
fd(10)
else :
rt(60)
fd(10)
a = a+1
On obtient un fragment du flocon de Koch
__
a = 0
while a < 2**16 :
if t[a] == 0 : # ou == 1
rt(60)

3. fd(10)
a = a+1
donne un petit hexagone
__
a = 0
while a < 2**16 :
if t[a] == 0 :
fd(10)
else :
rt(60)
a = a+1
On retrouve le flocon de Koch tracé d'une autre manière
__
a = 0
while a < 2**16 :
if t[a] == 0 :
fd(10)
else :
rt(30)
fd(10)
avec l'angle de 30, on obtient probablement le flocon mais plus grossier encore

4. __
a = 0
while a < 2**16 :
if t[a] == 0 :
fd(10)
else :
rt(90)
on obtient le symbole suivant !
__
a = 0
while a < 2**16 :
if t[a] == 0 :
fd(10)
else :
rt(90)
fd(10)
de même :
__
a = 0
while a != 2**16:
if t[a] == 0 :
fd(10)
else :
rt(45)
fd(10)
a=a+1

5. donne :
__
a = 0
while a != 2**16:
if t[a] == 0 :
fd(10)
else :
rt(45)
a=a+1
__
a = 0
while a != 2**16:
if t[a] == 1 : # ou 0 d'ailleurs
fd(10)
else :
rt(135)
a=a+1
__
a = 0
while a != 2**16:
if t[a] == 0 :
fd(10)
else :
rt(135)
fd(10)
a=a+1

6. __
while a != 2**16:
if t[a] == 0 :
fd(10)
else :
rt(120)
fd(10)
a=a+1
__
while a != 2**16:
if t[a] == 0 :
fd(10)
else :
rt(150)
fd(10)
a=a+1

7. __
while a != 2**16:
if t[a] == 0 :
fd(10)
else :
rt(150)
a=a+1
ET
while a != 2**16:
if t[a] == 0 :
fd(10)
else :
rt(120)

8. a=a+1
donnent aussi d'autres versions du flocon de Koch
__
notons
le remplacement de ==0 par ==1 entraine seulement une rotation de la figure
passons maintenant à la comparaison de deux termes de la suite
a = 0
while a != 2**16:
if t[a] == t[a+1] :
fd(10)
else :
rt(60)
fd(10)
a=a+1
60 = 180-(360/3)
__
while a != 2**16:
... if t[a] == t[a+1] :
... fd(10)
... else :
... rt(30)
... fd(10)
... a=a+1

9. pas de période observée
orbite plutôt stable autour d'un centre se déplacement lentement ?
__
while a != 2**16:
if t[a] == t[a+1] :
fd(10)
else :
rt(45)
fd(10)
a=a+1
bassin stable, aux allures pentagonales sans le centre, allure « nuage électronique »
__
while a != 2**16:
... if t[a] == t[a+1] :
... fd(10)
... else :
... rt(108)
... fd(10)
... a=a+1
108 = angle d'un pentagone
__

10. while a != 2**16:
... if t[a] == t[a+1] :
... fd(10)
... else :
... rt(72)
... fd(10)
... a=a+1
72 = 360/5
extra !
Il faudrait réessayer en laissant le tracé beaucoup plus longtemps
avec un pas de 4 (dézoom)
aspect « cathédrale »
__
while a != 2**16:
if t[a] == t[a+1] :

11. fd(10)
else :
rt(216)
fd(10)
a=a+1
Bassin à priori stable, en forme d'oursin (← pentagone vu de côté...?).
__
while a != 2**16:
if t[a] == t[a+1] :
fd(10)
else :
rt(90)
fd(10)
a=a+1
quadrillage carré de forme triangulaire (… ? à grande échelle?)
90 = 180-360/4 = 360/4 ; influence du 4
Voici la même figure avec un pas de 1 pixel (dézoom)...en cours de construction :

12. Ressemble à une construction humaine...?
Pas de motif final, étrange coin amoché, brisé,
__
while a != 2**16:
if t[a] == t[a+1] :
fd(10)
else :
rt(120)
fd(10)
a=a+1
Espace quadrillé parcouru et reparcouru, élargi peu à peu
__

13. while a != 2**16:
if t[a] == t[a+1] :
fd(10)
else :
rt(150)
fd(10)
a=a+1
bassin à priori stable, pentagonal (environ), à voir dans le temps
__
while a != 2**16:
if t[a] == t[a+1] :
fd(10)
else :
rt(240)
fd(10)
a=a+1
240 même type que 120
__
while a != 2**16:
... if t[a] == t[a+1] :
... fd(10)
... else :
... rt(360/7)
... fd(10)
... a=a+1

14. influence du nombre 7
bassin à peu près stable, ou évolue très lentement, (humain vue de haut, tête)
__
while a != 2**16:
... if t[a] == t[a+1] :
... fd(10)
... else :
... rt(180-(360/7))
... fd(10)
... a=a+1
influence du 7, angle de l'heptagone
Enorme ! Mandala, étoile à 14 branche (Tempérance)
__
while a != 2**16:
... if t[a] == t[a+1] :
... fd(10)
... else :
... rt(135)
... fd(10)
... a=a+1
135 = 180-360/8 , angle de l'octogone

15. On retrouve le flocon de Koch qu'on avait laissé en changeant l'algorithme !
__
while a != 2**16:
... if t[a] == t[a+1] :
... fd(10)
... else :
... rt(140)
... fd(10)
... a=a+1
140 : angle de l'ennéagone, influence du 9
! Croissance quasi végétale, très naturelle, supposée infinie d'une structure étoilée !
À laisser tourner une nuit !
Processus de construction très très impressionnant, renforcement des structures existantes avant de

16. poursuivre plus loin, … !!!
Croissance régulière, mais entretient des asymétries, qui entretiennent le mouvement.
Elargissement de la structure sous forme de boucles, cellules, plus stable.
Stabilisation en un Mandala à 18 branches !

17. __
while a != 2**16:
if t[a] == t[a+1] :
fd(10)
else :
rt(40)
fd(10)
a=a+1
40 = 360/8
pas laissé assez longtemps
__
J'oubliais bien entendu 180, la ligne :
while a != 2**16:
... if t[a] == t[a+1] :
... fd(10)
... else :
... rt(180)
... fd(10)
... a=a+1
Le segment du haut indique le pas
Le tracé est donc une segment de deux pas <=> il n'y a jamais plus de deux 0 de suite
__

18. Tout petit décalage de l'angle droit :
while a != 2**16:
... if t[a] == t[a+1] :
... fd(10)
... else :
... rt(91)
... fd(10)
... a=a+1
Mandala qui doit être très long à achever
décalage encore plus petit :
while a != 2**16:
... if t[a] == t[a+1] :
... fd(10)
... else :

19. ... rt(90.1)
... fd(10)
... a=a+1
__
nombre d'or
while a != 2**16:
if t[a] == t[a+1] :
fd(10)
else :
rt(360/b)
fd(10)
a=a+1
avec b le nombre d'or b = 1.6180339887498948482045868343656381177203091798057628621354

20. Phi semble bien s'exprimer mais attention aux approximations, et donc au décalage.
Autre :
while a != 2**16:
if t[a] == t[a+1] :
fd(10)
else :
rt(180-360/b)
fd(10)
a=a+1
Pseudo mandala :
Et pour Pi :
while a != 2**16:
if t[a] == t[a+1] :

21. fd(10)
else :
rt(180-360/b)
fd(10)
a=a+1
avec pi = b = 3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534

22. (fd:4)
Observation : émergence d'une structure connue = segments de 1 ou 2 avec possible rotation de 108
degrés <=> écart de 72 degré à la trajectoire
→ pour l'instant, émergence de la même figure que pour 72 degré !!!
puis
obtenu avec
while a != 2**16:
if t[a] == t[a+1] :
fd(20)
else :
rt(72)
fd(20)
a=a+1
Le motif d'auto-similarité de cet algo était :

23. A vérifier
pour 2**16 termes de la suite
On observe un petit décalage dans la figure, peut-être dû à une approximation inévitable de pi.
Difficile à vérifier.
On peut assurer un peu plus la conjecture en poussant un peu plus loin pour observer l'éventuel
changement attendu (par analogie à l'angle de 90°).
Essayons à 2**20 (et attendons...)
L'approximation de pi par python est à 2.4e-16 près (sous estimation), ce qui revient à un écart
angulaire de max 10^-14 et cette erreur s'accumule à chaque rotation. Quelle est la probabilité de
rotation ? Question intéressante, à développer plus tard. Disons ¾, alors l'approximation
entrainerait, pour le tracé selon 2^16 termes, un décalage d'angle de 4.10^-10 degré environ, ce qui
est encore insignifiant.
L'écart ici semble 10^10 fois plus grand : mesure de l'angle entre la direction en début de tracé
(segment du haut) et en fin de tracé d'environ 5 degré sur la dernière figure (ils devrait être alignés
si le motif émergent est celui produit par l'algo 7). Autre perte de précision dans l'algo ? Mauvaise
conjecture ?
Le motif semble pourtant vraiment prendre l'allure conjecturée à ce petit décalage près.
Conjecture : le motif émergent avec l'algo(180-360/pi) (algo(≈65.41)) pour 2**16 termes de la
séquence est le même que celui produit par l'algo72 pour 2**4 termes.
La conjecture ne se vérifie pas sur un plus long terme. Le caractère émergent est tout de même
notable. Pour quelle plage de valeur d'angle ce phénomène est-il effectif ?

24. Ce motif ne semble pas être ancré dans une échelle, mais en constante émergence à une échelle
supérieure.
Test algo(65.41)
while a != 2**20:
if t[a] == t[a+1] :
fd(1)
else :
rt(65.41)
fd(1)
a=a+1

25. Il y a bien une divergence avec le tracé précédent mais toujours ce comportement émergent.
__
Autre :
while a != 2**16:
if t[a] == t[a+1] :
fd(10)
else :
rt(360/b)
fd(10)
a=a+1
b = pi
Mandala ! Soleil, particule...
__
a = 0
while a != 2**20-1:
if t[a] == t[a+1] :
fd(20)
else :
rt(180-360/(b/2))
fd(20)
a=a+1

26. à suivre
__
while a != 2**20-1:
if t[a] == t[a+1] :
fd(2)
else :
rt(180-360/(2*b))
fd(2)
a=a+1
b=pi

27. __
while a != 2**20-1:
if t[a] == t[a+1] :
fd(10)
else :
rt(180-360/(2**0.5))
fd(10)
a=a+1
racine de 2

28. __
a = 0
while a != 2**20-1:
if t[a] == t[a+1] :
fd(10)
else :
rt(360/(2**0.5))
fd(10)
a=a+1

29. __
Pi au carré :
>>> while a != 2**20:
... if t[a] == t[a+1] :
... fd(5)
... else :
... rt(180-360/pi**2)
... fd(5)
... a=a+1

30. __
while a != 2**20-1:
if t[a] == t[a+1] :
fd(10)
else :
rt(360/e)
fd(10)
a=a+1
e = 2.71828182845904523536

32. while a != 2**20:
if t[a] == t[a+1] :
fd(5)
else :
rt(360/e)
a=a+1

33. while a != 2**20:
if t[a] != t[a+1] :
fd(5)
else :
rt(360/e)
a=a+1
while a != 2**20:
if t[a] == t[a+1] :
fd(20)
else :
rt(180-360/e)
a=a+1

34. while a != 2**20:
if t[a] != t[a+1] :
fd(20)
else :
rt(180-360/e)
a=a+1
__
while a != 2**20:
if t[a] == t[a+1] :
fd(5)
else :
rt(360/e)
fd(5)
a=a+1

35. while a != 2**20:
if t[a] != t[a+1] :
fd(5)
else :
rt(360/e)
fd(5)
a=a+1

36. __
while a != 2**20:
if t[a] == t[a+1] :
fd(20)
else :
rt(360/e**2)
fd(20)
a=a+1
while a != 2**20:

37. if t[a] == t[a+1] :
fd(5)
else :
rt(180-360/e**2)
fd(5)
a=a+1
Autre :
Cercle ! (ou plutôt polygone)
while a!= 2**20 :
fd(1)
rt(t[a])
a=a+1
print(pos(), a)

38. Complété au bout de 720 termes (720 = 2*360) et d'un diamètre ce 229.8
while a != 2**20 :
fd(10*t[a])
rt(1)
a=a+1
print(pos(), a)
Cercle complété après 360 termes, de diamètre 572.94
while a != 2**20 :
fd(10*t[a])
rt(a)
a=a+1
print(pos(), a)

40. Spirales de Pythagore !
while a != 2**20 :
... fd(a/10000)
... rt(t[a])
... a=a+1
while a != 2**20 :
fd(a/1000)
rt(t[a])
a=a+1

41. Observation intéressante, si on ne commence pas à a=0, alors le tracé est « insignifiant », ou plutôt
très simple, à vérifier/approfondir...
Autre question intéressante : pour le figures stabilisées, y a-t-il une période, et à partir de quel terme
de la suite le tracé est-il complet ?