La spirale des nombres premiers de Ulam avec la tortue

Renée De Graeve

2018

1 Introduction
2 Le dessin d’une spirale
3 Les procédures utiles pour écrire les nombres $k_0,k_0+1...K$ selon une spirale
4 Les nombres $k_0,k_0+1...K$ ( $1\leq k_0\leq K$ ) dessinant une spirale
- 4.1 La procédure spirentier(p,k,n,b)
- 4.2 La procédure spiralentier(k0,K,n)
5 Exercice
6 La spirale des nombres premiers
- 6.1 On écrit les nombres premiers en rouge et les autres en noir
- 6.2 On repère seulement les nombres premiers à l’aide d’un carré rouge
7 La spirale des nombres premiers jumeaux
8 La spirale, les nombres premiers, la tortue et la récursivité
- 8.1 Les nombres premiers jumeaux avec une récursivité terminale
- 8.2 Les nombres premiers avec une récursivité non terminale
9 Exercice :les nombres premiers jumeaux avec une récursivité non terminale
10 Les nombres premiers de la forme $6k-1$ et $6k+1$ pour $k\geq 1$

1 Introduction

En 1963, lors d’une communication ennuyeuse Stanislas M. Ulam de l’université de Los Alamos écrit les entiers naturels selon une spirale, et il entoure les nombres premiers. À sa grande surprise il obtient beaucoup d’alignements.
Nous allons faire faire à la tortue ce qu’a fait Stanislas M. Ulam :

Le dessin d’une spirale,
L’écriture des entiers $k_0,k_0+1...K$ selon une spirale ( $k_0\geq 1$ ),
Repérer dans la spirale, les nombres premiers par un carré rouge,
Repérer dans la spirale, les nombres premiers jumeaux par un carré bleu.

2 Le dessin d’une spirale

une spirale est formé de spires qui sont les 2 côtés contigüs d’un carré.
Voici le programme qui réalise le dessin d’une spirale ayant $p$ spires dont les dimensions vont de $n$ jusqu’à $p*n$ .

fonction spirale(p,n=10)
  local k;
  recule n; tourne_droite 90;
  avance n,tourne_gauche 90;
  pour k de 2 jusque p faire
  repete (2,avance k*n,tourne_gauche 90);
fpour;
ffonction:;

onload
efface;saute 30;pas_de_cote 30;spirale(20,10)

3 Les procédures utiles pour écrire les nombres $k_0,k_0+1...K$ selon une spirale

3.1 Les polygones réguliers

Définir une procédure isopoly(p,n) qui trace un polygone régulier de côté de longueur $n$ et ayant $p$ sommets.

fonction isopoly(p,n)
  repete(p,avance n,tourne_gauche 360/p);
ffonction:;

onload
efface;pas_de_cote -50; isopoly(3,100);isopoly(4,100);isopoly(5,100);isopoly(6,100);

3.2 La procédure ecrisdans(a,n)

À chaque position de la tortue, on appelle carré direct- $n$ , le carré de côté $n$ que peut décrire la tortue.
Définir une procédure ecrisdans(a,n) qui écrit au centre de ce carré.
On utilisera l’instruction ecris(a,b) qui écrit a avec la fonte b (par défaut b=14) à l’endroit où se trouve la tortue sans tenir compte de son orientation (a est soit une chaîne, soit un nombre, soit un nom de variable contenant une chaîne ou un nombre).

fonction ecrisdans(a,n=15,b=14)
  pas_de_cote n/2;
  saute n/2;
  ecris(a,b);
  saute -n/2;
  pas_de_cote -n/2;
ffonction:;

onload
Pour voir la différence entre ecrisdans et ecris :
efface;repete(4,isopoly(4,50),ecrisdans(1,50,20),avance 100,tourne_gauche 90);saute 150;ecrisdans("fin",50,20)

efface;repete(4,isopoly(4,50),ecris(1,20),avance 100,tourne_gauche 90);saute 150;ecrisdans("fin",50,20)

On tape par exemple :
efface;pour k de 1 jusque 4 faire isopoly(4,50);ecrisdans(100*k,50,10);avance 100;tourne_gauche 90;fpour;

3.3 La procédure carrentier(a,n)

Définir la procédure carrentier(a,n) qui trace un carré direct de côté n, qui écrit a au centre de ce carré puis qui saute de n pour que la tortue soit prête à écrire l’entier suivant.

fonction carrentier(a,n=15,b=14)
  isopoly(4,n);
  ecrisdans(a,n,b);
  saute n;
ffonction:;

onload
efface;carrentier(1,30);carrentier(2,30);carrentier(3,30)

efface;carrentier(1,30,10);carrentier(2,30,10);tourne_gauche;saute 30;carrentier(3,30,10)

4 Les nombres $k_0,k_0+1...K$ ( $1\leq k_0\leq K$ ) dessinant une spirale

On va tout d’abord décrire ce que l’on doit faire pour placer les nombres $1,2..10$ selon la spirale :
efface;spiralentier(1,13,30,10)

On commence par écrire 1 avec carrentier(1,n) et grâce à saute n contenu dans carrentier(1,n,b) on pourra écrire 2.
On écrit 2 avec carrentier(2,n,b) et grâce à saute n contenu dans carrentier(2,n,b) la tortue se trouve dans un angle donc :
pour que 3 se trouve au dessus de 2, la tortue doit tourner à gauche et sauter, puis, on écrit 3.
Grâce à saute n contenu dans carrentier(3,n,b) la tortue se trouve à nouveau dans un angle donc :
pour que 4 se trouve à gauche de 3, la tortue doit tourner à gauche et sauter ....
Définition Lorsque la tortue écrit dans une suite de $p$ carrés les nombres $k,k+1,..k+p-1$ puis tourne à gauche et saute pour écrire dans une suite de $p$ carrés,situés au dessus du carré $k+p-1$ , les nombres $k+p,k+p1,..k+2p-1$ puis tourne à gauche et saute, on dit que la tortue a effectué une spire qui sera la procédure spirentier(p,k,n,b) (n donne la dimension du carré et b la taille de la fonte servant à écrire $k$ ).
On tape pour faire la première spire (p=1) :
carrentier(2,n,b);tourne_gauche; saute n;
carrentier(3,n,b);tourne_gauche; saute n;.
On appelle tgsa(n) (abreviation tourne_gauche saute n) (resp tgav(n) (abreviation tourne_gauche avance n)) la procédure qui fait passer de l’écriture de 2 à l’écriture de 3.
Puis pour faire la deuxième spire (p=2) :
on écrit 4,5, tgsa(n), on écrit 6,7,tgsa(n) puis :
Puis pour faire la troisième spire (p=3) :
on écrit 8,9,10, tgsa(n), on écrit 11,12,13,tgsa(n) etc ..
On appelle spirentier(p,k,n,b) (p>=1) la procédure qui pour j $\in$ [0,1...p-1] exécute : carrentier(j+k,n,b); tgsa(n); puis pour pour j $\in$ [p,p+1...2p-1] exécute carrentier(j+k,n,b); tgsa(n)

4.1 La procédure spirentier(p,k,n,b)

On définit la procédure spirentier(p,k,n,b)

fonction tgsa(n=15)
  tourne_gauche;
  saute n;
ffonction:;
fonction tgav(n=15)
  tourne_gauche;
  avance n;
ffonction:;
fonction spirentier(p,k,n=15,b=12)
  local j;
  pour j de 0 jusque p-1 faire
    carrentier(j+k,n,b);
  fpour;
  tgsa(n);
  pour j de p jusque 2p-1 faire
    carrentier(j+k,n,b);
  fpour;
  tgsa(n);
ffonction:;

onload
Voici le début de la spirale,le départ en noir, la première spire en rouge, la deuxiéme spire en vert avec les nombres écrits avec une fonte de 12 :
efface;crayon 0;carrentier(1,30,12);crayon 1;spirentier(1,2,30,12);crayon 2;spirentier(2,2+2*1,30,12)

Voici la suite de la spirale, la troisième spire en jaune, la quatriéme en bleu, la cinqième en magenta et la sixième en cyan avec les nombres écrits avec une fonte de 10):
crayon 3;spirentier(3,4+2*2,30);crayon 4;spirentier(4,8+2*3,30,10);crayon 5;spirentier(5,14+2*4,30,10);crayon 6;spirentier(6,22+2*5,30,10)
efface;pas_de_cote -30;crayon 3;spirentier(3,4+2*2,30);crayon 4;spirentier(4,8+2*3,30,10);crayon 5;spirentier(5,14+2*4,30,10);crayon 6;spirentier(6,22+2*5,30,10)

4.2 La procédure spiralentier(k0,K,n)

On définit la procédure spiralentier(k0,K,n,b) qui écrit selon une spirale, les entiers $k_0 k_0+1...K$ lorsque $1\leq k_0\leq K$ :

fonction spiralentier(k0,K,n=25,b=6)
  local k,p;
  k:=k0;
  //ecrisdans(k,n);avance n;
  carrentier(k,n,b);
  p:=1;
  k:=k+1;
  tantque k<=K faire
    spirentier(p,k,n,b);
    k:=k+2*p;
    p:=p+1;
  ftantque;
  avance 0;
ffonction:;

onload
efface;saute 25;pas_de_cote 10;spiralentier(1,100,23,6)

efface;saute 25;spiralentier(41,100,25,6)

Remarque et exercice
Si $K$ est un entier contenu de spirentier(p,k,n=15), montrer que spiralentier(k0,K,n,b) écrit selon une spirale, les entiers $k_0..1+p*(p+1)$ .
spiralentier(k0,K,n,b) écrit les entiers contenus dans une spire donc spiralentier(k0,K,n,b) écrit selon une spirale, les entiers de $k_0$ jusqu’à $k_0+p*(p+1)$ si $(p-1)p+k_0<K \leq p(p+1)+k_0$ .
Par exemple si :
$k_0=1$ , $K=100$ on a $p=10$ car $9*10+1=91<100\leq 111=10*11+1$ , spiralentier(1,100,n,b) écrit selon une spirale, les entiers de 1 juqu’à 111 .
$k_0=41$ , $K=100$ on a $p=8$ car $7*8+41<97\leq 113=8*9+41$ , spiralentier(41,100,n,b) écrit selon une spirale, les entiers de 41 juqu’à 113 .
Montrer que $p=$ ceil $((-1+\sqrt{1+4(K-k0)})/2)$ .
$k_0=1$ alors $p=$ ceil $((-1+\sqrt{4K-3})/2)$ .
K:=90;ceil((-1+sqrt(4*K-3))/2)

K:=100;ceil((-1+sqrt(4*K-3))/2)

K:=111;ceil((-1+sqrt(4*K-3))/2)

Si $k_0=1$ et $K=100$ spiralentier(k0,K,n,b) écrit les entiers de 1 jusque $111 =p*(p+1)+1$ car $p=10$ .
Si $k_0=41$ et $K=100$ spiralentier(k0,K,n,b) écrit les entiers de 41 jusque $113 =p*(p+1)+1$ car $p=8$ .
Pour vérifier :
K:=100;p1:=ceil((-1+sqrt(1+4*(K-1)))/2);p0:=ceil((-1+sqrt(1+4*(K-41)))/2)

p1*(p1+1)+1,p0*(p0+1)+41

Correction
Cherchons le dernier nombre $u_p$ de spirale(p,k0,n,b).
) On a :
$u_0=k_0$ , $u_1=3=k_0+2*1$ , $u_2=u_1+2*2=k_0+2*1+2*2$ .... $u_p=u_{p-1}+2*p$ donc
$u_p=k_0+2(1+2...p)=p(p+1)+k_0$ et $u_{p-1}=(p-1)p+1=p^2-p+k_0$ . Etant donné un entier $K$ cherchons l’entier $p$ tel que :
$u_{p-1}<K \leq u_p$ i.e. $p^2-p<K-k_0 \leq p^2+p$ . Soient $x_1$ et $x_2$ ( $x_1<0<x_2$ ) les racines de $P(x)=x^2+x+k_0-K=0$ . On a $x_1=(-1-sqrt(1+4*(K-k_0)))/2$ et $x_2=(-1+sqrt(1+4*(K-k_0)))/2$ .
Dire que :
$p^2-p+k_0-K=f(p-1)<0$ veut dire que $p-1$ se trouve entre $x_1$ et $x_2$ $p^2+p+k_0-K=f(p)\geq 0$ veut dire, puisque $p>0$ , que $p$ se trouve dans $[x_2 +\infty$ donc on a :
$p-1<x_2\geq p$ donc
$p$ est le plus petit entier supérieur ou égal à $x_2$ donc
$p=$ ceil $(x_2)=$ ceil $((-1+sqrt(1+4*(K-k_0)))/2)$ .
Donc lorsque $1\leq k_0\leq K$ , si $p==$ ceil $((-1+sqrt(1+4*(K-k_0)))/2)$ , la procédure spiralentier(k0,K,n,b) écrit selon une spirale, les entiers $k_0 k_0+1...p(p+1)+k_0$ .
efface;spiralentier(1,91,25,8)

efface;spiralentier(41,83,30,10)

5 Exercice

Écrire les entiers de $k0$ jusque $K$ selon une spirale en ne dessinant que la spirale sans dessiner le contour des carrés par exemple :
efface;spiralentierexo(1,31,30,10)

fonction tgav(n)
  tourne_gauche;
  avance n;
ffonction:;
fonction spirentierexo(p,k,n=25,b=8)
  local j;
  pour j de 0 jusque p-1 faire
    ecrisdans(j+k,n,b);avance n;
  fpour;
  tgav(n);
  pour j de p jusque 2p-1 faire
    ecrisdans(j+k,n,b);avance n;
  fpour;
  tgav(n);
ffonction:;
fonction spiralentierexo(k0,K,n=25,b=8)
  local k,p;
  k:=k0;
  //ecrisdans(k,n);saute n;
  carrentier(k,n,b);
  p:=1;
  k:=k+1;
  tantque k<=K faire
    spirentierexo(p,k,n,b)
    k:=k+2*p;
    p:=p+1;
  ftantque;
  avance 0;
ffonction:;

onload
efface;pas_de_cote 18;saute 20;spiralentierexo(1,100,22,6)

efface;pas_de_cote 12;saute 20;spiralentierexo(41,100,27,7)

6 La spirale des nombres premiers

6.1 On écrit les nombres premiers en rouge et les autres en noir

On veut écrire dans la spirale, les nombres premiers en rouge et les nombres non premiers en noir. Pour cela on va modifier les procédures ecrisdans, carrentier en ecrisprem, carreprem :

fonction carreprem(k,n=25,b=8)
  ecrisprem(k,n,b);
  isopoly(4,n);
  saute n;
ffonction:;
fonction ecrisprem(k,n=25,b=8)
  pas_de_cote n/2;
  saute n/2;
  si est_premier(k) alors 
    crayon 1;
  sinon
    crayon 0;
  fsi;
  ecris(k,b);
  saute -n/2;
  pas_de_cote -n/2;
ffonction:;
fonction spireprem(p,k,n=25,b=8)
  local j;
  pour j de 0 jusque p-1 faire
    ecrisprem(j+k,n,b);
    avance n;
  fpour;
  tgav(n);
  pour j de p jusque 2p-1 faire
    ecrisprem(j+k,n,b);
    avance n;
  fpour;
  tgav(n);
ffonction:;
fonction spiraleprem(k0,K,n=25,b=8)
  local j,k,p;
  k:=k0;
  carreprem(k,n,b);
  p:=1;
  k:=k+1;
  tantque k<=K faire
    spireprem(p,k,n,b)
    k:=k+2*p; 
    p:=p+1;
  ftantque;
  avance 0;
ffonction:;

onload
Remarque On termine la procédure spiraleprem par avance 0; pour que la dernière instruction évaluée soit une instruction tortue.
efface;saute 40;spiraleprem(1,73,25,10)

efface;spiraleprem(41,113,25,7)

6.2 On repère seulement les nombres premiers à l’aide d’un carré rouge

Dans la spirale, on veut repérer seulement les nombres premiers à l’aide d’un carré rempli de rouge. Pour cela on va modifier les procédures :
ecrisprem, carreprem en premcarre.
On repère par un disque noir le début de la spirale en $k_0$ .

fonction premcarre(k,n=15)
  si est_premier(k) alors 
    rectangle_plein(n,n);
  fsi;
  saute n;
ffonction:;
fonction spirepremcarre(p,k,n=15)
  local j;
  pour j de 0 jusque p-1 faire
    premcarre(j+k,n);
  fpour;
  tgsa(n);
  pour j de p jusque 2p-1 faire
    premcarre(j+k,n);
  fpour;
  tgsa(n);
ffonction:;
fonction spiralepremcarre(k0,K,n)
  local k,p;
  k:=k0;
  crayon 1;
  premcarre(k,n);
  saute -n/2;
  crayon 0;
  disque 2;
  saute n/2;
  p:=1;
  k:=k+1;
  crayon 1;
  tantque k<=K faire
    spirepremcarre(p,k,n);
    k:=k+2*p;
    p:=p+1;
  ftantque;
  avance 0;
ffonction:;

onload
efface;saute 50;pas_de_cote 25;spiralepremcarre(1,1001,7)

efface;saute 50;pas_de_cote 25;spiralepremcarre(41,1041,7)

7 La spirale des nombres premiers jumeaux

On veut repérer dans la spirale que les nombres premiers jumeaux à l’aide d’un carré bleu et les nombres premiers non jumeaux à l’aide d’un carré rouge. Pour cela on va modifier les procédures ecrisprem, carreprem en carrepremjum

fonction tgsa(n)
  tourne_gauche;
  saute n;
ffonction:;
fonction carrepremjum(k,n=15)
  si est_premier(k)  alors 
    si est_premier(k+2) alors 
      crayon 4; rectangle_plein(n,n);     
    sinon
      si (0+crayon)==4 alors 
         rectangle_plein(n,n);crayon 1;
      sinon  
         crayon 1;rectangle_plein(n,n);
      fsi;
    fsi;
  fsi;
  saute n;
ffonction:;
fonction spirepremjum(p,k,n=15)
  local j;
  pour j de 0 jusque p-1 faire
    carrepremjum(j+k,n);
  fpour;
  tgsa(n);
  pour j de p jusque 2p-1 faire
    carrepremjum(j+k,n);
  fpour;
  tgsa(n);
ffonction:;
fonction spiralepremjum(k0,K,n=15)
  local k,p,c;
  k:=k0;
  carrepremjum(k,n);
  c:=0+crayon;
  saute -n/2;
  crayon 0;disque 2;
  saute n/2;
  crayon c;
  p:=1;
  k:=k+1;
  tantque k<=K faire
    spirepremjum(p,k,n);
    k:=k+2*p;
    p:=p+1;
  ftantque;
  avance 0;
ffonction:;

onload
efface;pas_de_cote 10;spiralepremjum(1,100,20)

efface;spiralepremjum(41,1013,5)

8 La spirale, les nombres premiers, la tortue et la récursivité

8.1 Les nombres premiers jumeaux avec une récursivité terminale

On peut décomposer la spirale débutant par k0+1 et se terminant par la spire contenant K en :

le départ : departspirale(k0,n=15),
la spirale par une spire de longueur 2p2p débutant par k0+1 et se terminant par la spire contenant K : spiralepremjumr(p,k0,K,n=15).
Cette spirale est formée par :
- la première spire spirepremjum(p,k0+1,n),
- la fin de la spirale spiralepremjumr(p+1,k0+2*p,K,n).

On écrit les procédures pour avoir les nombres premiers jumeaux et non jumeaux : departspirale(k0,n=15) traite le nombre $k0$ en mettant un petit disque noir pour pouvoir repérer le point de départ.
spirepremjum(p,k0+1,n) a été déjà programmé spiralepremjumr(p+1,k0,K,n=15) est la procédure récursive qui se termine lorsque $k0\geq K$ on écrit alors la dernière valeur traitée.

fonction departspirale(k0,n=15)
  carrepremjum(k0,n);
  c:=0+crayon;
  saute -n/2;
  crayon 0;disque 2;
  saute n/2;
  crayon c;
ffonction:;
fonction spirepremjum(p,k,n=15)
  local j;
  pour j de 0 jusque p-1 faire
    carrepremjum(j+k,n);
  fpour;
  tgsa(n);
  pour j de p jusque 2p-1 faire
    carrepremjum(j+k,n);
  fpour;
  tgsa(n);
ffonction:;
fonction spiralepremjumr(p,k0,K,n=15)
  si k0<K alors
    spirepremjum(p,k0+1,n);
    spiralepremjumr(p+1,k0+2*p,K,n);
  sinon
    saute -n;
    ecris k0;
  fsi;
  avance 0;
ffonction:;
fonction spiralepremj(k0,K,n=15)
  local p;
  departspirale(k0,n);
  spiralepremjumr(1,k0,K,n);
ffonction:;

onload
efface;saute 20;departspirale(1,20);spiralepremjumr(1,1,111,20)

efface;spiralepremj(47,1111,5)

8.2 Les nombres premiers avec une récursivité non terminale

Rappel
La $p$ ième spire ( $p>0$ ) d’une spirale débutant par k0, commence à k0+p*(p-1)+1 et se termine par p*(p+1)+k0. Si K est un nombre contenu dans une spire cette spire est de longueur 2*p avec p:=ceil((-1+sqrt(1+4*(K-k0)))/2) car k0+p*(p-1)<K<=k0+p*(p+1).
On écrit les procédures pour avoir les nombres premiers avec un carré rouge. La procédure spiralepremrec(k0,K,n) est récursive et définit la spirale débutant par k0 et se terminant par la spire contenant K : cette spirale a donc p:=ceil((-1+sqrt(1+4*(K-k0)))/2) spires.
On décompose cette spirale spiralepremrec(k0,K,n) en

le début de la spirale qui a p-1 spires donc qui se termine par le nombre K=p*(p-1)+k0 : spiralepremrec(k0,p*(p-1)+k0,n)
la dernière spire qui est la pième spire qui commence par p*(p-1)+k0+1 : spirepremcarre(p,p*(p-1)+k0+1,n)

On utilise les procédures précédentes qu’on rappelle ici.

fonction tgsa(n)
  tourne_gauche;
  saute n;
ffonction:;
fonction premcarre(k,n=15)
  si est_premier(k) alors 
    rectangle_plein(n,n);
  fsi;
  saute n;
ffonction:;
fonction spirepremcarre(p,k,n=15)
  local j;
  pour j de 0 jusque p-1 faire
    premcarre(j+k,n);
  fpour;
  tgsa(n);
  pour j de p jusque 2p-1 faire
    premcarre(j+k,n);
  fpour;
  tgsa(n);
ffonction:;
fonction spiralepremrec(k0,K,n=15)
  local p;
  p:=ceil((-1+sqrt(1+4*(K-k0)))/2);
  si p<=0 alors
    si est_premier(k0) alors 
      crayon 1 ;
      rectangle_plein(n,n);    
    fsi;
    saute n/2;crayon 0;disque(2);crayon 1 ;
    saute n/2;
  sinon
    spiralepremrec(k0,p*(p-1)+k0,n);
    spirepremcarre(p,p*(p-1)+k0+1,n);
  fsi;
ffonction:;

onload
efface;pas_de_cote 20;saute 20;spiralepremrec(1,2000,5)

efface;pas_de_cote 20;saute 20;spiralepremrec(41,2000,5)

9 Exercice :les nombres premiers jumeaux avec une récursivité non terminale

Écrire une procédure récursive non terminale pour avoir les nombres premiers jumeaux et non jumeaux en s’aidant de ce qui précède.

fonction tgsa(n)
  tourne_gauche;
  saute n;
ffonction:;
fonction carrepremjum(k,n=15)
  si est_premier(k)  alors 
    si est_premier(k+2) alors 
      crayon 4; rectangle_plein(n,n);     
    sinon
       si (0+crayon)==4 alors 
         rectangle_plein(n,n);crayon 1;
       sinon  
         crayon 1;rectangle_plein(n,n);
       fsi;
    fsi;
  fsi;
  saute n;
ffonction:;
fonction spirepremjum(p,k,n=15)
  local j;
  pour j de 0 jusque p-1 faire
    carrepremjum(j+k,n);
  fpour;
  tgsa(n);
  pour j de p jusque 2p-1 faire
    carrepremjum(j+k,n);
  fpour;
  tgsa(n);
ffonction:;
fonction spiralepremjrec(k0,K,n=15)
  local p,c;
  p:=ceil((-1+sqrt(1+4*(K-k0)))/2);
  si p<=0 alors
    carrepremjum(k0,n);
    c:=0+crayon;
    saute -n/2;crayon 0;disque(2);
    saute n/2;crayon c;
  sinon
    spiralepremjrec(k0,p*(p-1)+k0,n);
    spirepremjum(p,p*(p-1)+k0+1,n);
  fsi;
ffonction:;

onload
efface;pas_de_cote 20;saute 20;spiralepremjrec(1,2000,5)

efface;pas_de_cote 20;saute 20;spiralepremjrec(41,2000,5)

10 Les nombres premiers de la forme $6k-1$ et $6k+1$ pour $k\geq 1$

On cherche les nombres premiers jumeaux et non jumeaux de la forme $6k-1$ et $6k+1$ pour $k\geq 1$ .
On décide de visualiser $6k-1$ et $6k+1$ par un carré : lorsque la tortue a comme cap 0,le triangle inférieur gauche représente $6k-1$ et le triangle supérieur droit représente $6k+1$ .
Si $6k-1$ et $6k+1$ sont des nombres premiers jumeaux, on décide colorier ces 2 triangles en bleu pour obtenir au final un carré bleu.
Si $6k-1$ (resp $6k+1$ ) est un nombre premier non jumeaux, on décide colorier son triangle en rouge (l’autre triangle restant blanc).
On range ensuite ces carrés selon une spirale comme précédemment en utilisant les fonctions déjà écrites tgsa, ecrisdans.
La fonction finale spiraleprem6(k0,P,n=16,b=8) :

écrit k0 et dessine le carré correspondant à 6*k0-1 et 6*k0+1 puis,
fait P spires de longueur 1*2, 2*2,...2PP.
Rappel pour faire une spire de longueur 2p2p la tortue fait pp carrés côte à côte puis tourne à gauche, saute et fait à nouveau pp carrés côte à côte.
- la première spire dessine 2 carrés : le carré traitant 6*(k0+1)-1 et 6*(k0+1)+1 et le carré traitant 6*(k0+2)-1 et 6*(k0+2)+1 puis,
- fait la deuxième spire jusqu’à la Pième spire.

Au total, le dessin final trace 1+1*2+2*2+2*3+...+2*P=1+P(P+1) carrés qui correspondent aux valeurs de k allant de k0 jusqu’à k0+P*(P+1).
On traite donc les nombres premiers qui vont de 6*k0-1 jusqu’à 6*(k0+P*(P+1))+1.

fonction tgsa(n)
  tourne_gauche;
  saute n;
ffonction:;

fonction ecrisdans(k,n=15,b=14)
  pas_de_cote n/2;
  saute n/2;
  crayon 0;
  ecris(k,b);
  saute -n/2;
  pas_de_cote -n/2;
ffonction:;

fonction carreprem6(k,n=16)
  local c1,c2;
  si est_premier(6*k-1) alors 
     c1:=1; 
  sinon 
     c1:=7;
  fsi;
  si est_premier(6*k+1) alors 
     c2:=1; 
  sinon 
     c2:=7;
  fsi;
  si c1+c2==2 alors 
     crayon 4; 
     rectangle_plein(n,n);
      saute n;
  sinon
     crayon c2; 
     rectangle_plein(n,n);
     crayon c1; 
     triangle_plein(n,n);
     saute n;
  fsi;
ffonction:;

fonction spireprem6(p,k,n=16)
  local j;
  pour j de 1 jusque p faire
     carreprem6(k,n);
     k:=k+1;
  fpour; 
  tgsa(n);
  pour j de 1 jusque p faire
     carreprem6(k,n);
     k:=k+1;
  fpour; 
  tgsa(n);
ffonction:;

fonction spiraleprem6(k0,P,n=16,b=8)
  local p,k;
  carreprem6(k0,n);
  ecrisdans(k0,n,b);
  saute n;
  k:=k0+1;
  pour p de 1 jusque P faire
    spireprem6(p,k,n);
    k:=k+2*p;
  fpour;
  saute -n;
  ecrisdans(k-1,n,b);
ffonction:;

onload
efface;spiraleprem6(41,10,16,6)

On a tracé $1+2*\sum_{k=1}^{10}k=1+10*11$ carrés pour $k$ allant de $41$ à $41+10*11$ pour traiter les nombres allant de $6*41-1$ à $6*(41+10*11)+1$ .
41, 41+2*sum(k,k=1..10),6*41-1,6*(41+10*11)+1

efface;pas_de_cote 10;saute 20;spiraleprem6(1001,20,10,6)

On a tracé $1+2*\sum_{k=1}^{20}k=1+20*21$ carrés pour $k$ allant de $1001$ à $1001+20*21$ pour traiter les nombres allant de $6*1001-1$ à $6*(1001+20*21)+1$ .
1001,1001+20*21, 6*1001-1, 6*(1001+20*21)+1