\documentclass{article}
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}
\usepackage{amsmath}
\usepackage{amsfonts}
\usepackage{latexsym}
\usepackage{amssymb}
\usepackage{times}
\usepackage{ifpdf}
\usepackage{makeidx}
\usepackage{graphicx}
\ifpdf
 \usepackage[pdftex,colorlinks]{hyperref}
\else
 \usepackage[ps2pdf,breaklinks=true,colorlinks=true,linkcolor=red,citecolor=green]{hyperref}
 \fi

\newtheorem{rem}{Remark}
\newcommand{\R}{{\mathbb{R}}}
\newcommand{\C}{{\mathbb{C}}}
\newcommand{\Z}{{\mathbb{Z}}}
\newcommand{\N}{{\mathbb{N}}}
\newcommand{\Q}{{\mathbb{Q}}}
\newcommand{\atan}{{\mbox{atan}}}
%\newcommand{\faux}{$\square\;$}
%\newcommand{\vrai}{$\square\;$}
%\newtheorem{thm}{Theorem}
%\newtheorem{exo}{Exercice}[section]
\input{giac.tex}
\giacmathjax
\title{La spirale des nombres premiers de Ulam}
\author{Ren\'ee De Graeve et Bernard Parisse}
\date{2018}
\begin{document}
\begin{giacjshere}
\maketitle
\tableofcontents
\newpage
\section{Introduction}
En 1963, lors d'une communication ennuyeuse Stanislas M. Ulam de l'universit\'e 
de Los Alamos \'ecrit les entiers naturels selon une spirale, et il entoure
les nombres premiers (ici ils seront \'ecrits en rouge). \`A sa grande surprise 
il obtient beaucoup d'alignement.\\
Voici la spirale de Ulam et le crible d'Eratosth\`ene pour les entiers de 1 
\`a 56  :\\
\giacinputbig{axes=0;spirale(48),segment(4.1-3*i,4.1+4*i),tabprem6(4.3-3*i,48)}

\section{Programme qui \'ecrit les entiers de 1 \`a $n$  en spirale}
On peut choisir :\\
\begin{enumerate}
\item  soit constituer la spirale au fur et \`a mesure : c'est le choix de 
Bernard Parisse.
\item soit \'ecrire une fonction $f$ qui \`a un entier de $1..n$ renvoie son 
affixe dans la spirale : c'est le choix de Ren\'ee De Graeve.
\end{enumerate}
\section{Programme \'ecrivant les chiffres de 1 \`a $n$ au fur et \`a mesure}
\subsection{D\'escription de l'algorithme}
Les nombres \`a \'ecrire sont \'ecrits selon 4 directions :
on appelle {\tt dir} la variable qui indique la direction :\\
si {\tt dir} vaut 1, on \'ecrit les nombres de gauche \`a droite selon l'axe r\'eel,\\ 
si {\tt dir} vaut i, on \'ecrit les nombres de bas en haut selon l'axe imaginaire,\\ 
si {\tt dir} vaut -1, on \'ecrit les nombres de droite \`a gauche selon l'axe r\'eel,\\ 
si {\tt dir} vaut -i, on \'ecrit les nombres de haut en bas  selon l'axe imaginaire.\\
Au d\'epart on \'ecrit le nombre 1 \`a l'origine du rep\`ere puis,\\
on \'ecrit le nombre 2  de gauche \`a droite selon l'axe r\'eel (i.e \`a droite du 1 ) puis on change de direction et\\ 
on \'ecrit le nombre (3) de bas en haut selon l'axe imaginaire (i.e au dessus du 2), puis on change de direction et\\
on \'ecrit 2 nombres (4 et 5) de droite \`a gauche selon l'axe r\'eel,\\ 
puis on change de direction et\\
on \'ecrit 2 nombres (6 et 7) de haut en bas  gauche \`a droite selon l'axe 
r\'eel, puis on change de direction et\\
on \'ecrit 3 nombres (8,9,10) de gauche \`a droite selon l'axe r\'eel
puis on change de direction et \\
on \'ecrit  3 nombres (11,12,13) de bas en haut selon l'axe imaginaire,
puis on change de direction et\\
 on \'ecrit 4 nombres (14,15,16,17) de droite \`a gauche selon l'axe r\'eel, 
puis on change de direction et\\
on \'ecrit 4 nombres (18,19,20,21) de haut en bas selon l'axe imaginaire,
 puis on change de direction et\\
on \'ecrit 5 nombres (22,23,24,25,26) de gauche \`a droite selon l'axe r\'eel
puis on change de direction et \\
on \'ecrit  5 nombres (27,28,29,30,31) de bas en haut selon l'axe imaginaire,
puis on change de direction etc....\\
Combien faut-il \'ecrire d'entiers sans changer de direction ?\\
Soit {\tt k}  le nombre d'entiers \`a \'ecrire sans changer de direction.\\
Au d\'ebut {\tt k} vaut 0 et {\tt dir} vaut 1 eton \'ecrit le nombre 1 \`a 
l'origine du rep\`ere puis, on augmente {\tt k} de 1 i.e {\tt k} 
vaut 1, donc on \'ecrit 2 \`a droite de 1, puis on change de direction i.e. 
{\tt dir:=dir*i}.\\
Maintenant {\tt dir} vaut i et on ne change pas {\tt k} donc on \'ecrit 3 au 
dessus de 2, puis on change de direction i.e. {\tt dir:=dir*i}.\\
Maintenant {\tt dir} vaut -1 et on augmente {\tt k} de 1, i.e {\tt k} vaut 2 
donc on \'ecrit 4,5 de droite \`a gauche selon l'axe r\'eel, puis
 on change de direction i.e. {\tt dir:=dir*i}.\\
Maintenant {\tt dir} vaut -i, on ne change pas {\tt k} donc on \'ecrit 6,7 de 
haut en bas puis on change de direction i.e. {\tt dir:=dir*i}.\\
Maintenant {\tt dir} vaut 1 et on augmente {\tt k} de 1,....\\
Donc {\tt k} augmente donc de 1 lorsque la direction vaut 1 ou -1 i.e. quand la 
direction est un nombre r\'eel on augmente {\tt k} de 1.\\
\subsection{Le programme des nombres premiers \'ecrits en spirale au fur et \`a mesure}
On veux avoir avoir un programme dans lequel les nombres entiers de 1 \`a $n$ 
sont \'ecrits selon une spirale, en \'ecrivant les nombres premiers en rouge.\\
\'Ecrire les nombres n'est valable que losque $n$ est petit. On va donc aussi \' ecrire dans lequel on ne dessine que des carr'es rouges \`a l'emplacement des nombres premiers, les nombres entiers de 1 \`a $n$ \'etant bien s\^ur 
\'ecrits selon une spirale.\\
Ici on \'ecrit les 2 programmes en un seul gr\^ace au param\`etre {\tt nombre} :\\
lorsque  {\tt nombre} vaut 1 on \'ecrit les nombres selon une spirale en \'ecrivant les nombres premiers en rouge et \\
lorsque  {\tt nombre} vaut 0 on ne dessine que des carr'es rouges \`a l'emplacement des nombres premiers.\\
On tape :
\begin{giaconload}
fonction spirale2prem(n,nombre=0)
  local L,j,k,N,z,dir;
  N:=1; z:=0; L:=[];
  dir:=1;
  k:=0;
  si nombre alors
     L.append(couleur(legende(z,N),0));
  fsi; 
  tantque N<n faire
    si im(dir)==0 alors k++; fsi;
    pour j de 1 jusque k faire
      z += dir;
      N += 1;
      si N==n+1 alors break fsi;
      si nombre alors
       si isprime(N) alors  L.append(couleur(legende(z,N),1));
       sinon L.append(couleur(legende(z,N),0));fsi;
      sinon
        si isprime(N) alors L.append(couleur(carre(z,z+1),rouge+rempli));
      fsi;
     fsi;
    fpour;
    dir := i*dir;
  ftantque;
  afficher(N);
  return L;
ffonction:;
\end{giaconload}
\giacinput{axes=0;spirale2prem(56,1)}\\
\giacinput{axes=0;spirale2prem(100,0)}\\
\giacinput{axes=0;spirale2prem(15000)}

\subsection{La spirale des nombres premiers et des premiers jumeaux}
 On peut modifer ce programme pour avoir les nombres premiers de 1 \`a $n$
r\'ep\'er\'e par des carr\'es rouge ou  bleu pour les nombres premiers jumeaux.
On remplit la spirale au fur et \`a  mesure.
\begin{giaconload}
fonction spiralejum(n)
  local L,j,k,N,z,dir,Np,zp;
  N:=1; z:=0; L:=[];
  dir:=1;
  //L.append(couleur(carre(z,z+1),rouge+rempli)); 
  k:=0;Np:=2;zp:=1;
  tantque N<n faire
    si im(dir)=0 alors k++; fsi;
    pour j de 1 jusque k faire
      z += dir; 
      N += 1;
      si isprime(N) alors 
        si N==Np+2 alors 
        L.append(couleur(carre(zp,zp+1),bleu+rempli));
        L.append(couleur(carre(z,z+1),bleu+rempli)); 
        sinon 
         L.append(couleur(carre(z,z+1),rouge+rempli)); 
        fsi;
        zp:=z;Np:=N;
       fsi;       
     fpour;
    dir := i*dir;
  ftantque;
  afficher(N);
return L;
ffonction:;
\end{giaconload}
\giacinput{axes=0;spiralejum(100)}\\
\giacinput{axes=0;spiralejum(150)}\\
\giacinput{axes=0;spiralejum(15000)}
\subsection{La spirale des nombres premiers et des premiers jumeaux d\'ebutant \`a  $n0$}
On remplit, au fur et \`a  mesure, la spirale d\'ebutant \`a  $n0$ par des 
carr\'es  bleu pour les nombres premiers jumeaux et rouge 
pour les nombres premiers non jumeaux.
\begin{giaconload}
fonction spiralejumn0(n0,n)
  local L,j,k,N,z,dir,Np,zp;
  N:=n0; z:=0; L:=[];
  dir:=1;
  //L.append(couleur(carre(z,z+1),rouge+rempli)); 
  k:=0;Np:=2;zp:=1;
  tantque N<n faire
    si im(dir)=0 alors k++; fsi;
    pour j de 1 jusque k faire
      z += dir; 
      N += 1;
      si isprime(N) alors 
        si N==Np+2 alors 
        L.append(couleur(carre(zp,zp+1),bleu+rempli));
        L.append(couleur(carre(z,z+1),bleu+rempli)); 
        sinon 
         L.append(couleur(carre(z,z+1),rouge+rempli)); 
        fsi;
        zp:=z;Np:=N;
       fsi;       
     fpour;
    dir := i*dir;
  ftantque;
  afficher(N);
return L;
ffonction:;
\end{giaconload}
\giacinput{axes=0;spiralejumn0(101,300)}\\
\giacinput{axes=0;spiralejumn0(41,2000)}\\
\giacinput{axes=0;spiralejumn0(15001,30000)}

\section{Le programme des nombres premiers \'ecrits en spirale avec leurs affixes}
\subsection{L'affixe des nombres entiers $n \geq 1$ \'ecrits selon une spirale: {\tt faffixe}}
Soit $faffixe$ la fonction qui \`a un entier $n\geq 1$ renvoie son affixe dans la 
spirale, en prenant comme rep\`ere orthonorm\'e
($faffixe(1),\overrightarrow{faffixe(1),faffixe(2)},\overrightarrow{faffixe(1),faffixe(4)}$).\\ 
On a donc :\\
$faffixe(1)=0$, $faffixe(2)=1$, $faffixe(3)=1+i$, $faffixe(4)=i$, $faffixe(5)=-1+i$,....,$faffixe(9)=1-i$,...\\
On remarque :
\begin{enumerate}
\item lorsque la spirale forme un carr\'e (par exemple 
$1,2,3,4$ ou $1,2,3,4,5,6,7,8,9$) les carr\'es se terminant par $(2p)^2$ ont 
pour affixe $-p+1+p*i$ et\\
 les carr\'es se terminant par $(2p+1)^2$ ont pour affixe $p-p*i$.\\ 
Donc :\\
si $a$ est pair alors $faffixe(a^2)=(-a+2+a*i)/2$ et \\
si $a$ est impair alors $faffixe(a^2)=(a-1+(-a+1)*i)/2$.
\item si $a$ est pair et si $a^2+1\leq n=a^2+k\leq a^2+a+1$, on a :\\
{\tt re($faffixe(n)$)=re($faffixe(a^2)$)}-$1=(-a+2)/2-1=-a/2$ \\
{\tt im($faffixe(n)$)=im($faffixe(a^2)$)}-$k+1=a/2-k+1$.\\
Donc :\\
 si $a^2=(2p)^2<n=a^2+k\leq a^2+a+1=(2p)^2+2p+1$ alors\\
$faffixe(n)=faffixe(a^2+k)=(-a+a*i)/2-(k-1)*i$ et $faffixe(a^2+a+1)=-a/2+a*i/2$
\item si $a$ est pair et si $a^2+a+1=(2p)^2+2p+1<n=a^2+a+1+j< (2p)^2+4p+1=(2*p+1)^2$ on a :\\
$n=a^2+k$ avec $k=a+1+j$ et\\
{\tt re($faffixe(n)$)=re($faffixe(a^2+a+1)$)}+$j=-a/2+k-a-1$ \\
{\tt im($faffixe(n)$)=im($faffixe(a^2)$)}=$-a/2$.\\
Donc :\\
si $a^2+a+1=(2p)^2+2p+1<n=a^2+a+1+j\leq (2p)^2+4p+1=(2*p+1)^2$ on a : \\
$faffixe(n)=faffixe(a^2+k)=(-a-a*i)/2+k-a-1$

\item si $a$ est impair et si $a^2=(2p+1)^2<n=a^2+k<a^2+a+1=(2p+1)^2+2p+2$ alors\\
{\tt re($faffixe(n)$)=re($faffixe(a^2)$)}+$1=(a-1)/2+1=(a+1)/2$ \\
{\tt im($faffixe(n)$)=im($faffixe(a^2)$)}-$k-1=(-a+1)/2+k-1$.\\
donc\\
$faffixe(n)=faffixe(a^2+k)=(a+1)/2+i*(-a+1)/2+i*(k-1)$ et donc\\
$faffixe(a^2+a+1)=(a+1)/2+i*(-a+1)/2+i*a=(a+1)/2+i*(a+1)/2$
\item si $a$ est impair et si $a^2+a+1=(2p+1)^2+2p+2<n=a^2+a+1+j<a^2+2a+1=(2p+2)^2$  on a :\\
$n=a^2+k$ avec $k=a+1+j$ et\\
{\tt re($faffixe(n)$)=re($faffixe(a^2+a+1)$)}-$j=(a+1)/2-k+a+1=-a/2-a*i/2$ \\
{\tt im($faffixe(n)$)=im($faffixe(a^2+a+1)$)}=$(a+1)/2$.\\
donc\\
$faffixe(n)=faffixe(a^2+k)=(a+1)/2+a+-k+1+i*(a+1)/2$
\end{enumerate}
On \'ecrit la fonction {\tt faffixe} :
\begin{giaconload}
fonction faffixe(n)
  local a,k,p,q,j;
  si n<=0 or type(n)!=integer alors 
     return "bad argument type"; 
  fsi;
  a:=floor(sqrt(n));k:=n-a^2;
  si est_impair(a) alors
    si k==0 alors return (a-1+i*(-a+1))/2; fsi;
    si k<=a+1 alors return (a+1+i*(-a+1))/2+i*(k-1); fsi;
    return (a+1+i*(a+1))/2-(k-a-1);
  sinon
    si k==0 alors return (-a+2+i*a)/2; fsi;
    si k<=a+1 alors return (-a+i*a)/2-(k-1)*i; fsi;
    return (-a-i*a)/2+k-a-1;
fsi;
 ffonction:; 
\end{giaconload}
\giacinput{faffixe(31),faffixe(37),faffixe(41),faffixe(43)}

\subsection{La spirale des nombres premiers $\geq 1$ avec la fonction {\tt faffixe}}
En utilisant la fonction {\tt faffixe} pr\'ec\'edente, on \'ecrit les nombres 
entiers de 1 \`a $n$, selon une spirale, en \'ecrivant les nombres premiers en 
rouge.\\
On tape :
\begin{giaconload}
fonction spirale(n)
  local k,L,b;
  L:=NULL;
   pour k de 1 jusque n faire
    b:=faffixe(k);
    //L:=L,carre(b,b+1);
    si est_premier(k) alors  
      L:=L,affichage(legende(b,k),1);
    sinon 
      L:=L,legende(b,k) ;fsi;
  fpour;
  return L;
ffonction:;
\end{giaconload}
\giacinput{axes=0;spirale(56)}\\
\giacinput{axes=0;gl_x=-6..6;spirale(81)}

\section{La spirale des nombres premiers $n \geq n0$ avec la fonction {\tt faffixe}}
On peut modifier l\'eg\`erement ce programme pour \'ecrire les nombres entiers 
de $n0$ \`a $n$ en \'ecrivant les nombres premiers en rouge.\\
\begin{giaconload}
fonction spiralen0(n0,n)
  local k,L,b;
  L:=NULL;
   pour k de n0 jusque n faire
    b:=faffixe(k-n0+1);
    //L:=L,carre(b,b+1);
    si est_premier(k) alors  
      L:=L,affichage(legende(b,k),1);
    sinon 
      L:=L,legende(b,k) ;fsi;
  fpour;
  return L;
ffonction:;
\end{giaconload}
\giacinput{axes=0;spiralen0(31,99)}\\
\giacinput{axes=0;spiralen0(41,99)}

\subsection{Programme n'affichant que les nombres premiers selon un carr\'e rouge}
Le programme {\tt spiralprem(n)} affiche, selon un carr\'e rouge, les nombres premiers inf\'erieur ou \'egaux \`a  {\tt n} selon une spirale.
\begin{giaconload}
fonction spiralprem(n)
  local k,L;
  L:=NULL;
   pour k de 1 jusque n faire
    si est_premier(k) alors  
      L:=L,affichage(carre(faffixe(k),faffixe(k)+1),1+rempli);
   fsi;
  fpour;
  return L;
 ffonction:; 
\end{giaconload}
\giacinput{axes=0;spiralprem(100)}\\
\giacinput{axes=0;spiralprem(15000)}

\subsection{Exercice : {\tt saffixe} une am\'elioration de {\tt faffixe}}
Dans le programme {\tt spiralprem} pr\'ec\'edent on ne calcule {\tt faffixe(n)} 
que lorsque {\tt n} est premier. Donc, puisque un carr\'e parfait n'est pas un 
nombre premier, on peut commenter plusieurs instructions :
\begin{giaconload}
fonction faffixe0(n)
  local a,k,p,q,j;
  //si n<=0 or type(n)!=integer alors  return "bad argument type"; fsi;
  a:=floor(sqrt(n));
  k:=n-a^2;
  si est_impair(a) alors
    //si k==0 alors return (a-1+i*(-a+1))/2; fsi;
    si k<=a+1 alors return (a+1+i*(-a+1))/2+i*(k-1); fsi;
    return (a+1+i*(a+1))/2-(k-a-1);
  sinon
    //si k==0 alors return (-a+2+i*a)/2; fsi;
    si k<=a+1 alors return (-a+i*a)/2-(k-1)*i; fsi;
    return (-a-i*a)/2+k-a-1;
fsi;
 ffonction:; 
\end{giaconload}
 Mais alors {\tt faffixe1(a\verb|^|2)} n'est pas correct !\\
\giacinput{faffixe(81),faffixe0(81),faffixe(82),faffixe0(82)}

{\bf Exercice}\\
Changer la premi\`ere instruction du programme {\tt faffixe0(n)} pour obtenir 
la fonction {\tt saffixe(n)} qui renvoie les affixes de tous les entiers {\tt n}
 qui sont strictement positifs.\\
{\bf Correction}\\
Pour faire l'algorithme de {\tt faffixe} on a rep\'er\'e les carr\'es (1,4,9,..
i.e. les croix rouges sur l'illustration suivante) et on a 
calcul\'e l'affixe de {\tt n} en fonction de {\tt a= floor(sqrt(n))} et cela 
nous a oblig\'e \`a trait\'e l'affixe des carr\'es \`a part (cf tracer1).\\
 Mais ce n'est pas le cas si on choisit de calculer l'affixe de {\tt n} en 
fonction de {\tt a= ceil(sqrt(n))-1} (cf tracer2).\\
\giacinputbig{gl_ortho=1,spir(-3+2*i),tracer1(-3+2*i),spir(-3-3*i),tracer2(-3-3*i)}
On tape :
\begin{giaconload}
fonction saffixe(n)
  local a,k,p,q,j;
  a:=ceil(sqrt(n))-1;
  k:=n-a^2;
  si est_impair(a) alors
    si k<=a+1 alors return (a+1+i*(-a+1))/2+i*(k-1); fsi;
    return (a+1+i*(a+1))/2-(k-a-1);
  sinon
    si k<=a+1 alors return (-a+i*a)/2-(k-1)*i; fsi;
    return (-a-i*a)/2+k-a-1;
fsi;
 ffonction:; 
 \end{giaconload}

\giacinputbig{saffixe(4),saffixe(25),saffixe(36),faffixe(4),faffixe(25),faffixe(36)}

\section{La spirale des carr\'es rouge repr\'esentant les nombres premiers}
\begin{giaconload}
fonction spiraleprem(n)
  local k,L,b;
  L:=NULL;
   pour k de 1 jusque n faire
    b:=saffixe(k);
    si est_premier(k) alors
      L:=L,affichage(carre(b,b+1),1+rempli);
     fsi;
  fpour;
  return L;
ffonction :;
fonction spiralepremn0(n0,n)
  local k,L,b;
  L:=NULL;
   pour k de n0 jusque n faire
    b:=saffixe(k-n0+1);
    si est_premier(k) alors
      L:=L,affichage(carre(b,b+1),1+rempli);
     fsi;
  fpour;
  return L;
ffonction:;
\end{giaconload}
\giacinput{axes=0;spiraleprem(15000)}\\
\giacinput{axes=0;spiralepremn0(101,3000)}

\section{Programmes qui ne teste que les nombres $6k-1$ et $6k+1$}
En effet les nombres premiers strictement sup\'erieur \`a 3 sont 
soit de la forme : $6k-1$ ou $6k+1$ pour $k$ entier strictement positif
$6k$ est divisible par 6, $6k+2$ est divisible par 2,
$6k+3$ est divisible par 3, $6k+4$ est divisible par 2.
donc seuls $6k +1$ et $6k+5=6*(k+1)-1$ peuvent \^etre premiers 
\subsection{La spirale des nombres premiers d\'ebutant \`a 1 ou \`a $n0$}
Lorsqu'on d\'ebute la spirale par $n0$, on peut avoir un programme plus simple
si on suppose que $n0$ est un mulitple de 6.\\
Comme on progresse de 6 en 6 en peut avoir une spirale qui va au del\`a de $n$.
\begin{giaconload}
fonction spiraleprem6(n)
  local k,L,a,b,z1,r;
  L:=NULL;
  r:=irem(n,6);
 // pour 2 et 3
  L:=L,affichage(carre(1,2),1+rempli);
  L:=L,affichage(carre(1+i,2+i),1+rempli);
  pour k de 6 jusque n+6-r pas 6 faire
  (a,b):=(est_premier(k-1),est_premier(k+1));
      si  a==1  alors
        z1:=saffixe(k-1)
        L:=L,affichage(carre(z1,z1+1),1+rempli);
      fsi;
      si b==1  alors
        z1:=saffixe(k-1);
        L:=L,affichage(carre(z1,z1+1),1+rempli);
      fsi;
    fpour;
  return L;
ffonction:;

fonction spiraleprem6n0(n0,n)
  local k,L,a,b,r,z1,r0,n1;
  L:=NULL;
  r0:=irem(n0,6);
  r:=irem(n,6);
  //n+(6-r)=6*q+r0+(6-r0)=6*(q+1)
   pour k de n0 jusque n0+6-r faire
    b:=saffixe(k-n0+1);
    si est_premier(k) alors
      L:=L,affichage(carre(b,b+1),1+rempli);
    fsi;
  fpour;
  n1:=n0+6-r0; 
  pour k de n1 jusque n+6-r pas 6 faire
      (a,b):=(est_premier(k-1),est_premier(k+1));
      si  a==1 alors 
        z1:=saffixe(k-n0);
        L:=L,affichage(carre(z1,z1+1),1+rempli);
      fsi;
      si  b==1 alors    
        z1:=saffixe(k+2-n0)
        L:=L,affichage(carre(z1,z1+1),1+rempli);  
      fsi;
  fpour;
  return L;
ffonction:; 
\end{giaconload}
\giacinput{axes=0;spiraleprem6(2000)}\\
\giacinput{axes=0;spiraleprem6(101)}\\
\giacinput{axes=0;spiraleprem6n0(41,5000)}

\subsection{La spirale des nombres premiers et les nombres premiers jumeaux
d\'ebutant \`a 1 ou \`a $n0$}
Les nombres premiers jumeaux sont 2 nombres premiers dont la diff\'erence vaut 2.\\
On ne sait toujours pas si il y en a une infinit\'e de nombres premiers 
jumeaux.\\
On rajoute la possibilit\'e de placer la spirale au point d'affixe {\tt z0}
\begin{giaconload}
fonction spiralejumeaux6(z0,n)
  local k,L,a,b,z1,z2 ;
  L:=NULL;
 // pour 2 et 3
  L:=L,affichage(z0+carre(1,2),1+rempli);
  L:=L,affichage(z0+carre(1+i,2+i),4+rempli);
  pour k de 6 jusque n-1 pas 6 faire
  (a,b):=(est_premier(k-1),est_premier(k+1));
  si a+b!=0 alors z1:=saffixe(k-1);z2:=saffixe(k+1)
    si [a,b]==[1,1] alors
      L:=L,affichage(z0+carre(z1,z1+1),4+rempli);
      L:=L,affichage(z0+carre(z2,z2+1),4+rempli);
    sinon 
      si  a==1  alors
        L:=L,affichage(z0+carre(z1,z1+1),1+rempli);
      sinon
          L:=L,affichage(z0+carre(z2,z2+1),1+rempli);
        fsi;
      fsi;
    fsi;
    fpour;
  return L;
ffonction:;

fonction spiralejumeaux6n0(z0,n0,n,nombre=0)
  local k,L,a,b,z1,z2,n1,r0,r;
  L:=NULL;
  r0:=irem(n0,6);r:=irem(n,6);
  si n0<=5 alors 
    pour k de n0 jusque 2 faire
      si est_premier (k) alors 
        z1:=saffixe(k-n0+1);
        L:=L,affichage(z0+carre(z1,z1+1),1+rempli);
         si nombre alors L:=L,affichage(legende(z0+z1,k),0);fsi;
      fsi;
    fpour;
     z1:=saffixe(3-n0+1);
     L:=L,affichage(z0+carre(z1,z1+1),4+rempli);
    si nombre alors L:=L,affichage(legende(z0+z1,3),0);fsi;
 sinon
   pour k de n0 jusque n0+6-r0 faire
      si isprime(k) alors print(k);
         z1:=saffixe(k-n0+1);
         L:=L,affichage(z0+carre(z1,z1+1),1+rempli);
          si nombre alors L:=L,affichage(legende(z0+z1,k),0);fsi;
      fsi;
   fpour;
 fsi;
   n1:=n0+6-r0;  
 pour k de n1 jusque n+6-r pas 6 faire 
   (a,b):=(est_premier(k-1),est_premier(k+1));
    si a+b!=0 alors z1:=saffixe(k-n0);z2:=saffixe(k+2-n0);
      si [a,b]==[1,1] alors
         L:=L,affichage(z0+carre(z1,z1+1),4+rempli);
         L:=L,affichage(z0+carre(z2,z2+1),4+rempli);
         si nombre alors 
            L:=L,affichage(legende(z0+z1,k-1),0);
            L:=L,affichage(legende(z0+z2,k+1),0);4
         fsi;
      sinon 
         si  a==1 alors 
           L:=L,affichage(z0+carre(z1,z1+1),1+rempli);
            si nombre alors L:=L,affichage(legende(z0+z1,k-1),0);fsi
         sinon 
           L:=L,affichage(z0+carre(z2,z2+1),1+rempli);
            si nombre alors L:=L,affichage(legende(z0+z2,k+1),0);fsi;
         fsi;
      fsi;
    fsi;
    fpour;
  return L;
ffonction:;
\end{giaconload}
\giacinputbig{axes=0;spiralejumeaux6(0,15000),spiralejumeaux6n0(130,15000,30000)}\\
\giacinput{axes=0;spiralejumeaux6n0(0,30011,36000);droite(y=x,affichage=3)}\\
\giacinput{axes=0;spiralejumeaux6n0(0,17,6000)}\\
\giacinput{axes=0;spiralejumeaux6n0(0,41,6000)}
\section{Les programmes utilis\'es}
\begin{giaconload}
fonction tabprem(z0,n)
  local j,k,L,a;
  L:=NULL;a:=floor(sqrt(n));
  pour j de 0 jusque a-1 faire
    pour k de 1 jusque a faire
       si isprime(j*a+k) alors 
         L:=L,affichage(carre(z0+k+j*i,z0+k+j*i+1),1+rempli);
         // L:=L,legende(k+j*i,j*a+k); 
       fsi;
    fpour;
  fpour;
  return L;
ffonction:;
fonction tabprem6(z0,n)
  local j,k,L,a;
  L:=NULL;
  a:=iquo(n,6);
  pour j de 0 jusque a-1 faire
    pour k de 1 jusque 6 faire
      //L:=L,carre(z0-1+k+j*i,z0+k+1+j*i);
      si isprime(j*6+k) alors 
      L:=L,affichage(legende(z0-1+k+j*i,j*6+k),1);
      sinon 
      L:=L,legende(z0-1+k+j*i,j*6+k) ;       
    fsi;
 fpour;
 fpour;
pour j de 1 jusque n-6*a faire
si isprime(6*a+j) alors 
      L:=L,affichage(legende(z0-1+j+a*i,6*a+j),1);
      sinon 
      L:=L,legende(z0-1+j+a*i,6*a+j) ;  
fsi;
fpour;
 return L;
ffonction :;
fonction spir(z0)
  local L;
  L:=NULL;
  L:=L,z0+segment(1+i,i);
  L:=L,z0+segment(0,i);
  L:=L,z0+segment(0,2);
  L:=L,z0+segment(2,2+2*i);
  L:=L,z0+segment(-1+2*i,2+2*i);
  L:=L,z0+segment(-1+2*i,-1-i);
  L:=L,z0+segment(3-i,-1-i);
  L:=L,z0+segment(3-i,3+3*i);
  L:=L,z0+segment(-2+3*i,3+3*i);
  return affichage(L,epaisseur_ligne_5);
ffonction :;
fonction tracer1(z0)
 local L;
L:=NULL; 
L:=L,affichage(z0+point(0.5+i*0.5),1+epaisseur_point_5);
L:=L,affichage(z0+point(0.5+i*1.5),1+epaisseur_point_5);
L:=L,affichage(z0+point(1.5-i*0.5),1+epaisseur_point_5);
L:=L,affichage(z0+point(-0.5+i*2.5),1+epaisseur_point_5);
L:=L,affichage(z0+segment(0.5+0.5*i,1.5+0.5*i),1);
L:=L,affichage(z0+segment(1.5+0.5*i,1.5+1.5*i),1);
L:=L,affichage(z0+segment(0.5+1.5*i,-0.5+1.5*i),1);
L:=L,affichage(z0+segment(-0.5-0.5*i,-0.5+1.5*i),1);
L:=L,affichage(z0+segment(-0.5-0.5*i,0.5-0.5*i),1);
L:=L,affichage(z0+segment(2.5-0.5*i,2.5+2.5*i),1);
L:=L,affichage(z0+segment(0.5+2.5*i,2.5+2.5*i),1);  
L:=L,affichage(z0+segment(1.5-0.5*i,2.5-0.5*i),1); 
return L;  
ffonction:;
fonction tracer2(z0)
 local L;
L:=NULL; 
 L:=L,affichage(z0+point(0.5+i*0.5),1+epaisseur_point_5);
L:=L,affichage(z0+point(0.5+i*1.5),1+epaisseur_point_5);
L:=L,affichage(z0+point(1.5-i*0.5),1+epaisseur_point_5);
L:=L,affichage(z0+point(-0.5+i*2.5),1+epaisseur_point_5);
L:=L,affichage(z0+segment(1.5+0.5*i,1.5+1.5*i),1);
L:=L,affichage(z0+segment(0.5+1.5*i,1.5+1.5*i),1);
L:=L,affichage(z0+segment(-0.5+1.5*i,-0.5-0.5*i),1);
L:=L,affichage(z0+segment(-0.5-0.5*i,1.5-0.5*i),1);
L:=L,affichage(z0+segment(2.5-0.5*i,2.5+2.5*i),1);
L:=L,affichage(z0+segment(-0.5+2.5*i,2.5+2.5*i),1);
return L;  
ffonction:;
\end{giaconload}


\end{giacjshere}
\end{document}








\begin{giaconload}
  return L;
fonction spirale20(n)
  local k,L;
  L:=NULL;
  pour k de 2 jusque 3 faire
    L:=L,affichage(carre(saffixe(k),saffixe(k)+1),1+rempli);
  fpour;
 // pour k de 4 jusque n pas 2 faire L:=L,affichage(carre(saffixe(k),saffixe(k)+1),2+rempli);fpour;
  pour k de 6 jusque n-1 pas 6 faire
    si est_premier(k-1) et est_premier(k+1) alors
      L:=L,affichage(carre(saffixe(k-1),saffixe(k-1)+1),4+rempli);
      L:=L,affichage(carre(saffixe(k+1),saffixe(k+1)+1),4+rempli);
    sinon 
      si  est_premier(k-1)  alors
        L:=L,affichage(carre(saffixe(k-1),saffixe(k-1)+1),1+rempli);
      sinon
        si  est_premier(k+1)  alors
          L:=L,affichage(carre(saffixe(k+1),saffixe(k+1)+1),1+rempli);
        fsi;
      fsi;
    fsi;
    fpour;
  return L;
ffonction:;
 
spirale1(n):={
  local k,L;
  L:=NULL;
  pour k de 1 jusque n faire
    si est_premier(k) alors 
      L:=L,affichage(carre(saffixe(k),saffixe(k)+1),1+rempli);;
    fsi;
  fpour;
  return L;;
}:;
spiral2(n):={
  local k,L;
  L:=NULL;
  pour k de 1 jusque n faire
    si est_pair(k) alors 
      L:=L,affichage(carre(saffixe(k),saffixe(k)+1),0+rempli);
    fsi;
    si est_premier(k) alors 
      L:=L,affichage(carre(saffixe(k),saffixe(k)+1),1+rempli);
    fsi;
  fpour;
  return L;;
}:;

\begin{giaconload}
spirale2(n0,n):={
  local k,L,b;
  L:=NULL;
   pour k de n0 jusque n faire
    b:=saffixe(k-n0+1);
    si est_premier(k) alors
      L:=L,affichage(carre(b,b+1),1+rempli);
     fsi;
  fpour;
  return L;
}:;   
 spiralejumeauxn0(n0,n):={
  local k,L,a,b,z1,z2,z3,n1 ;
  L:=NULL;
  si n0<4 alors 
   pour k de 2 jusque 3 faire
   z3:=saffixe(k-n0+1);
    L:=L,affichage(carre(z3,z3+1),1+rempli);
  fpour;
fsi;
n1:=6*iquo(n0,6)+6;
pour k de n0 jusque n1-1 faire
    si isprime(k) alors
    z3:=saffixe(k-n0+1);
    L:=L,affichage(carre(z3,z3+1),1+rempli);
fsi;
  fpour;
  pour k de n1 jusque n-1 pas 6 faire
  (a,b):=(est_premier(k-1),est_premier(k+1));
  si a+b!=0 alors z1:=saffixe(k-1-n0);z2:=saffixe(k+1-n0)
    si [a,b]==[1,1] alors
      L:=L,affichage(carre(z1,z1+1),4+rempli);
      L:=L,affichage(carre(z2,z2+1),4+rempli);
    sinon 
      si  a==1  alors
        L:=L,affichage(carre(z1,z1+1),1+rempli);
      sinon
          L:=L,affichage(carre(z2,z2+1),1+rempli);
        fsi;
      fsi;
    fsi;
    fpour;
  return L;
    }:;
\end{giaconload}

\begin{giaconload}
fonction saffixe(n)
  local a,k,p,q,j;
  a:=ceil(sqrt(n))-1;
  k:=n-a^2;
  si est_impair(a) alors
    si k<=a+1 alors afficher(n,1,1);
return (a+1+i*(-a+1))/2+i*(k-1); fsi;
    afficher(n,1,2);
    return (a+1+i*(a+1))/2-(k-a-1);
  sinon
    si k<=a+1 alors afficher(n,2,1);
return (-a+i*a)/2-(k-1)*i; fsi;
    afficher(n,2,2);
return (-a-i*a)/2+k-a-1;
fsi;
 ffonction:; 
\end{giaconload}
\begin{giaconload}
fonction faffixe(n)
  local a,k,p,q,j;
  si n<=0 or type(n)!=integer alors return "bad argument type"; fsi;
  a:=floor(sqrt(n));k:=n-a^2;
  si est_impair(a) alors
    si k==0 alors return (a-1+i*(-a+1))/2; fsi;
    si k<=a+1 alors return (a+1+i*(-a+1))/2+i*(k-1); fsi;
    return (a+1+i*(a+1))/2-(k-a-1);
  sinon
    si k==0 alors return (-a+2+i*a)/2; fsi;
    si k<=a+1 alors return (-a+i*a)/2-(k-1)*i; fsi;
    return (-a-i*a)/2+k-a-1;
fsi;
 ffonction:; 
 
fonction  spiral(n)
  local k,L;
  L:=NULL;
  pour k de 1 jusque n faire
    L:=L,carre(faffixe(k),faffixe(k)+1);
    si est_premier(k) alors 
      L:=L,affichage(legende(faffixe(k),k),1);
     sinon L:=L,legende(faffixe(k),k) ;
    fsi;
  fpour;
  return L;
ffonction:; 
 
fonction tabprem6(z0,n)
  local j,k,L,a;
  L:=NULL;
  a:=iquo(n,6);
  pour j de 0 jusque a-1 faire
    pour k de 1 jusque 6 faire
      //L:=L,carre(z0-1+k+j*i,z0+k+1+j*i);
      si isprime(j*6+k) alors 
      L:=L,affichage(legende(z0-1+k+j*i,j*6+k),1);
      sinon 
      L:=L,legende(z0-1+k+j*i,j*6+k) ;       
    fsi;
 fpour;
 fpour;
pour j de 1 jusque n-6*a faire
si isprime(6*a+j) alors 
      L:=L,affichage(legende(z0-1+j+a*i,6*a+j),1);
      sinon 
      L:=L,legende(z0-1+j+a*i,6*a+j) ;  
fsi;
fpour;
 return L;
ffonction :;

fonction tabprem(z0,n):={
 local j,k,L,a;
 L:=NULL;a:=floor(sqrt(n));
 pour j de 0 jusque a-1 faire
    pour k de 1 jusque a faire
      si isprime(j*a+k) alors 
         L:=L,affichage(carre(z0+k+j*i,z0+k+j*i+1),1+rempli);
      fsi;
    fpour;
 fpour;
 return L;
 ffonction:;
\end{giaconload}


\begin{giaconload}
spiralejumeaux6n0(n0,n):={
  local k,L,a,b,z1,z2,n1 ;
  L:=NULL;
  si n0<4 alors 
   pour k de n0 jusque 2 faire
   z1:=saffixe(k-n0+1);
    L:=L,affichage(carre(z1,z1+1),1+rempli);
  fpour;
   z1:=saffixe(3-n0+1)
   L:=L,affichage(carre(z1,z1+1),4+rempli);
fsi;
n1:=6*iquo(n0,6)+6;
pour k de n0 jusque n1-1 faire
    si isprime(k) alors
    z1:=saffixe(k-n0+1);
    L:=L,affichage(carre(z1,z1+1),1+rempli);
fsi;
  fpour;
  pour k de n1 jusque n-1 pas 6 faire
  (a,b):=(est_premier(k-1),est_premier(k+1));
  si a+b!=0 alors z1:=saffixe(k-1-n0);z2:=saffixe(k+1-n0)
    si [a,b]==[1,1] alors
      L:=L,affichage(carre(z1,z1+1),4+rempli);
      L:=L,affichage(carre(z2,z2+1),4+rempli);
    sinon 
      si  a==1  alors
        L:=L,affichage(carre(z1,z1+1),1+rempli);
      sinon
          L:=L,affichage(carre(z2,z2+1),1+rempli);
        fsi;
      fsi;
    fsi;
    fpour;
  return L;
    }:;
fonction spiralejumeauxn06(n0,n)
  local k,L,a,b,r,z1,z2;
  L:=NULL;
  r:=irem(n0,6);//n+(6-r)=6*q+r+(6-r)=6*(q+1)
   pour k de n0 jusque n0+6-r faire
    b:=saffixe(k-n0+1);
    si est_premier(k) alors
      L:=L,affichage(carre(b,b+1),1+rempli);
    fsi;
    //L:=L,legende(b,k);
  fpour;
  pour k de n0+6-r jusque n-1 pas 6 faire
  (a,b):=(est_premier(k-1),est_premier(k+1));
  si a+b!=0 alors z1:=saffixe(k-n0);z2:=saffixe(k+2-n0);
  si [a,b]==[1,1] alors
      L:=L,affichage(carre(z1,z1+1),4+rempli);
      L:=L,affichage(carre(z2,z2+1),4+rempli);
     // L:=L,legende(z1,k-1);L:=L,legende(z2,k+1);
    sinon 
      si  a==1 alors
        L:=L,affichage(carre(z1,z1+1),1+rempli);
        //L:=L,legende(z1,k-1);
      sinon
        L:=L,affichage(carre(z2,z2+1),1+rempli);
        //L:=L,legende(z2,k+1);
        fsi;
      fsi;
    fsi;
   // L:=L,legende(saffixe(k-1-n0),k);
  fpour;
  return L;
ffonction:; 
\end{giaconload}
\begin{giaconload}
fonction spiralejumeauxn06(z0,n0,n)
  local k,L,a,b,z1,z2,n1 ;
  L:=NULL;
  si n0<=5 alors 
    pour k de n0 jusque 2 faire
      si est_premier (k) alors 
        z1:=saffixe(k-n0+1);
        L:=L,affichage(z0+carre(z1,z1+1),1+rempli);
      fsi;
    fpour;
    z1:=saffixe(3-n0+1);
    L:=L,affichage(z0+carre(z1,z1+1),4+rempli);
    z1:=saffixe(5-n0+1);
    L:=L,affichage(z0+carre(z1,z1+1),4+rempli);
  sinon
    n1:=6*iquo(n0,6)+6;
    pour k de n0 jusque n1-2 faire
      si isprime(k) alors
        z1:=saffixe(k-n0+1);
        L:=L,affichage(z0+carre(z1,z1+1),1+rempli);
      fsi;
    fpour;
  fsi;
  n1:=6*iquo(n0,6)+6;
  pour k de n1 jusque n-1 pas 6 faire 
    (a,b):=(est_premier(k-1),est_premier(k+1));
     si a+b!=0 alors 
        z1:=saffixe(k-n0);
        z2:=saffixe(k+2-n0)
        si [a,b]==[1,1] alors
           L:=L,affichage(z0+carre(z1,z1+1),4+rempli);
           L:=L,affichage(z0+carre(z2,z2+1),4+rempli);
        sinon 
          si  a==1  alors 
             L:=L,affichage(z0+carre(z1,z1+1),1+rempli);
          sinon 
             L:=L,affichage(z0+carre(z2,z2+1),1+rempli);
          fsi;
        fsi;
      fsi;
    fpour;
  return L;
ffonction:;
fonction spiralejumeaux6(n)
  local k,L,a,b,z1,z2 ;
  L:=NULL;
 // pour 2 et 3
  L:=L,affichage(carre(1,2),1+rempli);
  L:=L,affichage(carre(1+i,2+i),4+rempli);
  pour k de 6 jusque n-1 pas 6 faire
  (a,b):=(est_premier(k-1),est_premier(k+1));
  si a+b!=0 alors z1:=saffixe(k-1);z2:=saffixe(k+1)
    si [a,b]==[1,1] alors
      L:=L,affichage(carre(z1,z1+1),4+rempli);
      L:=L,affichage(carre(z2,z2+1),4+rempli);
    sinon 
      si  a==1  alors
        L:=L,affichage(carre(z1,z1+1),1+rempli);
      sinon
          L:=L,affichage(carre(z2,z2+1),1+rempli);
        fsi;
      fsi;
    fsi;
    fpour;
  return L;
ffonction:;
fonction spiralejumeauxn06(z0,n0,n)
  local k,L,a,b,r,z1,z2;
  L:=NULL;
  r:=irem(n0,6);//n+(6-r)=6*q+r+(6-r)=6*(q+1)
   pour k de n0 jusque n0+6-r faire
    b:=saffixe(k-n0+1);
    si est_premier(k) alors
      L:=L,affichage(z0+carre(b,b+1),1+rempli);
    fsi;
    //L:=L,legende(b,k);
  fpour;
  pour k de n0+6-r jusque n-1 pas 6 faire
  (a,b):=(est_premier(k-1),est_premier(k+1));
  si a+b!=0 alors z1:=saffixe(k-n0);z2:=saffixe(k+2-n0);
  si [a,b]==[1,1] alors
      L:=L,affichage(z0+carre(z1,z1+1),4+rempli);
      L:=L,affichage(z0+carre(z2,z2+1),4+rempli);
     // L:=L,legende(z1,k-1);L:=L,legende(z2,k+1);
    sinon 
      si  a==1 alors
        L:=L,z0+affichage(carre(z1,z1+1),1+rempli);
        //L:=L,legende(z1,k-1);
      sinon
        L:=L,z0+affichage(carre(z2,z2+1),1+rempli);
        //L:=L,legende(z2,k+1);
        fsi;
      fsi;
    fsi;
   // L:=L,legende(saffixe(k-1-n0),k);
  fpour;
  return L;
ffonction:;  
fonction spiralepremn06(z0,n0,n)
  local k,L,a,b,r,z1;
  L:=NULL;
  r:=irem(n0,6);
  //n+(6-r)=6*q+r+(6-r)=6*(q+1)
   pour k de n0 jusque n0+6-r faire
    b:=saffixe(k-n0+1);
    si est_premier(k) alors
      L:=L,affichage(z0+carre(b,b+1),1+rempli);
    fsi;
  fpour;
  pour k de n0+6-r jusque n-1 pas 6 faire
      (a,b):=(est_premier(k-1),est_premier(k+1));
      si  a==1 alors 
        z1:=saffixe(k-n0);
        L:=L,affichage(z0+carre(z1,z1+1),1+rempli);
      fsi;
      si  b==1 alors    
        z1:=saffixe(k+2-n0)
        L:=L,affichage(z0+carre(z1,z1+1),1+rempli);
        
      fsi;
  fpour;
  return L;
ffonction:; 
\end{giaconload}
\begin{giaconload}
fonction spiraleBP(n,nombre=0)
  local L,j,k,N,z,dir;
  N:=1; z:=0; L:=[];
  dir:=1;
  k:=0;
  tantque N<n faire
    si im(dir)=0 alors k++; fsi;
    pour j de 1 jusque k faire
      z += dir;
      N += 1;
      si nombre alors
       si isprime(N) alors  L.append(couleur(legende(z,N),1));
       sinon L.append(couleur(legende(z,N),0));fsi;
      sinon
        si isprime(N) alors L.append(couleur(carre(z,z+1),rouge+rempli));
      fsi;
     fsi;
    fpour;
    dir := i*dir;
  ftantque;
  afficher(N);
  return L;
ffonction:;
\end{giaconload}
\giacinput{axes=0;spiraleBP(150,1)}\\
\giacinput{axes=0;spiraleBP(15000)}

\giacinput{axes=0;spirale2BP(31,1000)}\\
\giacinput{axes=0;spirale2BP(41,1000)}
