De surprenantes arithmétiques (fin ?)

Dans un premier article, André-Jean Glière a évoqué les nombres palindromes, les nombres de Lychrel, l’algorithme de Kaprekar et les nombres heureux. Dans un second article, il généralise l’algorithme définissant les nombres heureux en sommant les cubes des chiffres, puis les puissances $p$ des chiffres pour aboutir aux transformations agréables et aux nombres narcissiques. Dans cette suite (uniquement en ligne), il évoque les nombres parfaits, les nombres amiables et enfin les suites aliquotes.

André-Jean Glière

⋅⋅⋅⋅⋅⋅⋅⋅⋅⋅♦⋅⋅⋅⋅⋅⋅⋅⋅⋅⋅

Nombres parfaits

Nombre parfait
Un nombre $n$ est dit parfait s’il est égal à la somme de ses diviseurs stricts $s(n)$ : $s(n)=n$ autrement dit si et seulement si la somme de ses diviseurs $\sigma(n)$ vaut $2n$ : $\sigma(n)=2n$.

Exemples : les quatre nombres parfaits connus depuis l’Antiquité : $6$, $28$, $496$, ${8128}$.

On remarque que :

$6=2^1(2^2-1)=(1+2)+(3)$ ;
$28=2^2(2^3-1)=(1+2+4)+(7+14)$ ;
$496=2^4(2^5-1)=(1+2+4+8+16)+(31+62+124+248)$ ;
$8\,128=2^6(2^7-1)=(1+2+4+8+16+32+64)+(127+254+508+1\,016+2\,032+4\,064)$.

Deux théorèmes connus :

Au III^e siècle avant J.-C., le théorème d’Euclide :

Si $\dfrac{M_p(M_p+1)}{2}=2^{p-1}(2^p-1)$ est un nombre parfait.

La démonstration est facile et se fait en terminale spécialité maths.
Au XVIII^e siècle Euler démontre une pseudo-réciproque :

Tout nombre parfait pair est de cette forme.

La démonstration est plus difficile.

\[\begin{array}{|c|c|c|}
\hline
p\;\text{premier}&\text{Nombre de Mersenne premier}\;M_p=2^p-1&\text{Nombre parfait}\;2^{p-1}M_p\\
\hline
2&3&6\\\hline
3&7&28\\\hline
5&31&496\\\hline
7&127&8\,128\\\hline
13&8\,191&33\,550\,336\\\hline
17&131\,071&8\,589\,869\,056\\\hline
19&524\,287&137\,438\,691\,328\\\hline
\end{array}\]

Conjecture : il n’existe pas de nombre parfait impair.

À l’heure actuelle (novembre 2018), on connaît cinquante nombres parfaits qui correspondent à cinquante nombres de Mersenne premiers. Le plus grand nombre parfait connu correspond au plus grand premier connu. Il a été trouvé en décembre 2017 par le Great Internet Mersenne Prime Search (GIMPS), il vaut : \[2^{77\,232\,917}-1.\]

Quelques résultats connus :

La somme des inverses des diviseurs d’un nombre parfait vaut $2$ :

\[\begin{aligned}
\frac{1}{6}+\frac{1}{3}+\frac{1}{2}+\frac{1}{1}&=2\\
\frac{1}{28}+\frac{1}{14}+\frac{1}{7}+\frac{1}{4}+\frac{1}{2}+\frac{1}{1}&=2\\
\frac{1}{496}+\frac{1}{248}+\frac{1}{62}+\frac{1}{31}+\frac{1}{16}+\frac{1}{8}+\frac{1}{4}+\frac{1}{2}+\frac{1}{1}&=2\\
\frac{1}{8\,128}+\frac{1}{4\,064}+\frac{1}{2\,032}+\frac{1}{1\,016}+\frac{1}{508}+\frac{1}{254}+
\frac{1}{127}+\frac{1}{64}+\frac{1}{32}+\frac{1}{16}+\frac{1}{8}+\frac{1}{4}+\frac{1}{2}+\frac{1}{1}&=2\end{aligned}\]
Tous les nombres parfaits pairs, excepté le premier, sont la somme des $2^{\textstyle\frac{n-1}{2}}$ premiers cubes impairs.

Par exemple : $28=1^3+3^3$ ; $496=1^3+3^3+5^3+7^3$ ; $8\,128=1^3+3^3+5^3+7^3+9^3+11^3+13^3+15^3$.

Scripts Python

Fonction `estParfait1`
`def estParfait1(n):` `# La procédure affiche si oui ou non le nombre N est parfait` `sommeDiv=0` `# Initialisation de la variable à 0` `p=int(n/2)` `for k in range(1,p+1): :` `# inutile d'aller au-delà de p` `if(n%k==0):` `# (n%p==0) est Vrai si p divise n et Faux sinon.` `sommeDiv=sommeDiv+k` `# on incrémente sommeDiv` `if(sommeDiv==n):` `print("{}_est_un_nombre_parfait".format(n))` `else :` `print("{}_n'est_pas_un_nombre_parfait".format(n))`

Fonction estParfait1

def estParfait1(n):

# La procédure affiche si oui ou non le nombre N est parfait

sommeDiv=0

# Initialisation de la variable à 0

p=int(n/2)

for k in range(1,p+1): :

# inutile d'aller au-delà de p

if(n%k==0):

# (n%p==0) est Vrai si p divise n et Faux sinon.

sommeDiv=sommeDiv+k

# on incrémente sommeDiv

if(sommeDiv==n):

print("{}_est_un_nombre_parfait".format(n))

else :

print("{}_n'est_pas_un_nombre_parfait".format(n))

Fonction `estParfait2`
`def estParfait2(n) :` `# La fonction retourne le booléen Vrai si n est parfait et Faux sinon` `sommeDiv=0` `p=int(n/2)` `for k in range(1,p+1): :` `if(n sommeDiv=sommeDiv+k):` `return(sommeDiv==n)`

La procédure suivante affiche la liste des nombres parfaits inférieurs ou égaux à $nMax$.

Fonction `listenomParfait`
`def listeNomParfait(nMax) :` `print(“Liste des nombres parfaits de 2 à ”.format(nMax))` `for k in range(2,nMax+1) :` `if (estParfait2(k)==True) :` `print(k)`

Nombres amicaux et suites aliquotes

Première généralisation : nombres amicaux

Nombres amicaux (amiables)
Deux nombres $n$ et $m$ sont dits amicaux ou amiables s’ils sont distincts et si chacun des deux nombres est égal à la somme des diviseurs stricts de l’autre : $s(n)=m$ et $s(m)=n$ autrement dit si les sommes des diviseurs sont égales toutes les deux à $m+n$ : \[\sigma(n)=\sigma(m)=m+n.\]

Exemples

L’exemple le plus connu est la paire $\{220\, ;\,284\}$ où $220+284=504$.

En effet $s(220)=1+2+4+5+10+11+20+22+44+55+110=284$ et $s(284)=1+2+4+71+142=220$. ou $\sigma(220)=1+2+4+5+10+11+20+22+44+55+110+220=504$ et $\sigma(284)=1+2+4+71+142+284=504$.
Il existe douze autres paires de nombres amicaux de moins de six chiffres :

$\{{1\,184}\, ;\,{1\,210}\}$, $\{{2\,620}\, ;\,{2\,924}\}$, $\{{5\,020}\, ;\,{5\,564}\}$, $\{{6\,232}\, ;\,{6\,368}\}$, $\{{10\,744}\, ;\,{10\,856}\}$, $\{{12\,285}\, ;\,{14\,595}\}$,
$\{{17\,296}\, ;\,{18\,416}\}$, $\{{63\,020}\, ;\,{76\,084}\}$, $\{{66\,928}\, ;\,{66\,992}\}$, $\{{67\,095}\, ;\,{71\,145}\}$, $\{{69\,615}\, ;\,{87\,633}\}$, $\{{79\,750}\, ;\,{88\,730}\}$.

On connaît treize-mille paires de nombres amicaux, mais on ne sait pas s’il y en a une infinité. On ne connaît pas de paire mixte {pair ; impair}. On ne connaît pas de règle générale permettant de les trouver. En revanche, certains résultats partiels fournissent des exemples de paires amicales comme l’algorithme de Thébit :

Par exemple :

pour la valeur $n=2$, on retrouve la paire $\{220\, ;\,284\}$ ;
pour $n=3$, on obtient la paire $\{{17\,296}\, ;\,{18\,416}\}$.

En un sens, un nombre parfait est narcissique, car il est amical avec lui-même !

Scripts Python

Fonction `somDiv`
`def somDiv(n) :` `# La fonction retourne la somme des diviseurs de n` `nsomDiv=0` `for k in range(1,n+1) :` `if(n somDiv=somDiv+k) :` `# on incrémente la somme des diviseurs sommeDiv` `return somDiv`

La procédure suivante permet d’afficher les couples de nombres amicaux. On crée la liste des sommes des diviseurs des entiers jusqu’à $nMax$ et on compare les nombres de cette liste.

Fonction `listeNomAmicaux`
`def listeNomAmicaux(nMax) :` `# affiche la liste des couples amicaux jusqu’à nMax` `print(“Liste des nombres amicaux de 2 à {} :”.format(nMax))` `# On forme tout d’abord la liste des sommes des diviseurs des nombres de 1 jusqu’à nMax.` `liste=[]` `# on part d’une liste vide que l’on va compléter` `for j in range(1,nMax+1) :` `liste=liste+[somDiv(j)]` `# on concatène [somDiv(j)] à la liste` `# La liste est maintenant formée. Elle comporte nMax nombres, numérotés de 0 à nMax-1` `# (le nombre n°3 par exemple est la somme des diviseurs de 4). On l’explore en recherchant` `# les sommes identiques égales à la somme des deux nombres amicaux supposés.` `for i in range(nMax) :` `for k in range(i) :` `if(liste[k]==liste[i] and liste[k]==i+k+2) :` `# si k+1 et i+1 sont amicaux,` `print(“{} et {} sont amicaux”.format(k+1,i+1))` `# alors on les affiche`

Fonction listeNomAmicaux

def listeNomAmicaux(nMax) :

# affiche la liste des couples amicaux jusqu’à nMax

print(“Liste des nombres amicaux de 2 à {} :”.format(nMax))

# On forme tout d’abord la liste des sommes des diviseurs des nombres de 1 jusqu’à nMax.

liste=[]

# on part d’une liste vide que l’on va compléter

for j in range(1,nMax+1) :

liste=liste+[somDiv(j)]

# on concatène [somDiv(j)] à la liste

# La liste est maintenant formée. Elle comporte nMax nombres, numérotés de 0 à nMax-1

# (le nombre n°3 par exemple est la somme des diviseurs de 4). On l’explore en recherchant

# les sommes identiques égales à la somme des deux nombres amicaux supposés.

for i in range(nMax) :

for k in range(i) :

if(liste[k]==liste[i] and liste[k]==i+k+2) :

# si k+1 et i+1 sont amicaux,

print(“{} et {} sont amicaux”.format(k+1,i+1))

# alors on les affiche

Seconde généralisation : suites aliquotes

Suite aliquote
La somme des diviseurs stricts de $n$ est appelée la somme des parties aliquotes de $n$ ou la somme aliquote de $n$. Une suite aliquote est une suite d’entiers non nuls dans laquelle chaque terme est la somme des diviseurs stricts du précédent. C’est une suite d’itérées de la fonction $s$.

Nombre sociable
Un nombre $n$ est dit sociable d’ordre $k$ s’il existe une chaîne ou une suite aliquote de nombres entiers $n_1$, $n_2$, $n_3$, …, $n_k$ tels que : . Une telle chaîne est dite sociable.

Un nombre parfait est donc un nombre sociable d’ordre $1$ et les nombres amicaux des nombres sociables d’ordre $2$.

Méthode : pour calculer la suite aliquote d’un nombre $n=p_1^{\alpha_1}\times p_2^{\alpha_2}\times\cdots\times p_k^{\alpha_k}$, on peut utiliser la formule suivante $s(n)=(1+p_1+\cdots+p_1^{\alpha_1})\times(1+p_2+\cdots+p_2^{\alpha_2})\times\cdots\times(1+p_k+\cdots+p_k^{\alpha_k})-n$

Exemple : calcul de la suite aliquote de $30=2\times3\times5$.

\[\begin{aligned}
s(30)&=(1+2)(1+3)(1+5)-30=42=2\times3\times7,\\
s(42)&=(1+2)(1+3)(1+7)-42=54,\\
s(54)&=s(2\times3^3)=(2^2-1)\times\dfrac{3^4-1}{2}-54=66,\\
\text{etc.}
\end{aligned}\]

La suite aliquote de $30$ est ($30$, $42$, $54$, $66$, $78$, $90$, $144$, $259$, $45$, $33$, $15$, $9$, $4$, $3$, $1$, $0$).

Jean-Paul Delahaye¹ a représenté dans un tableau toutes les suites aliquotes des nombres jusqu’à $100$. On constate qu’à part celles des deux nombres parfaits $6$ et $28$ qui sont constantes et celles de $95$ et $25$ ($95\longmapsto25\longmapsto6$), toutes les autres suites aliquotes aboutissent à $1$.

Script Python

La procédure suivante calcule et affiche la suite aliquote du nombre $n$. Elle s’arrête quand elle rencontre soit le terme $1$, soit un terme déjà calculé.

Fonction `suiteAliquote`
`def suiteAliquote(n) :` `print(“La suite aliquote formée à partir de {} est la suivante :”.format(n)) listeAliquote=[]` `# Pour reconnaître quand on rentre dans un cycle, on mémorise # la liste des sommes aliquotes dans listeAliquote. # on l’initialise à la liste vide terme=n # le premier terme de la suite est n.` `while not (terme in listeAliquote) and(terme !=1) :` `# tant qu’on n’a pas déjà rencontré ce terme # et que ce n’est pas 1` `listeAliquote=listeAliquote+[terme]` `# on le concatènre à la liste.` `terme=somDiv(terme) - terme` `# on calcule le terme suivant. On soustrait terme # car somDiv est la somme de TOUS les diviseurs print(listeAliquote) # on affiche la liste cherchée.` `print(“le terme suivant est {}”.format(terme))` `# on calcule le terme suivant. On soustrait terme # car somDiv est la somme de TOUS les diviseurs print(listeAliquote) # on affiche la liste cherchée.` `if(terme==1) :` `# si terme vaut 1, alors la liste est stationnaire à 1.` `print(“la liste aliquote de {} aboutit au point fixe 1 en {} itérations”.format(n,len(listeAliquote)))` `else :` `print(“la liste aliquote de {} aboutit à une chaîne sociable après {} itérations”.format(n,len(listeAliquote)))`

Fonction suiteAliquote

def suiteAliquote(n) :

print(“La suite aliquote formée à partir de {} est la suivante :”.format(n))

listeAliquote=[]

# Pour reconnaître quand on rentre dans un cycle, on mémorise

# la liste des sommes aliquotes dans listeAliquote.

# on l’initialise à la liste vide terme=n

# le premier terme de la suite est n.

while not (terme in listeAliquote) and(terme !=1) :

 # tant qu’on n’a pas déjà rencontré ce terme

# et que ce n’est pas 1

listeAliquote=listeAliquote+[terme]

# on le concatènre à la liste.

terme=somDiv(terme) - terme

 # on calcule le terme suivant. On soustrait terme

# car somDiv est la somme de TOUS les diviseurs print(listeAliquote)

# on affiche la liste cherchée.

print(“le terme suivant est {}”.format(terme))

 # on calcule le terme suivant. On soustrait terme

# car somDiv est la somme de TOUS les diviseurs print(listeAliquote)

# on affiche la liste cherchée.

if(terme==1) :

# si terme vaut 1, alors la liste est stationnaire à 1.

print(“la liste aliquote de {} aboutit au point fixe 1 en {} itérations”.format(n,len(listeAliquote)))

else :

print(“la liste aliquote de {} aboutit à une chaîne sociable après {} itérations”.format(n,len(listeAliquote)))

Exécuter ce code avec les nombres $30$, $220$, ${8128}$, ${12496}$, ${14316}$, ${2856}$.

La suite aliquote de $30$ est connue et elle comporte $14$ itérations avant $1$.
La suite aliquote de $220$ est $(220,\ 284)$ puisque $220$ et $284$ sont deux nombres amicaux.
La suite aliquote de ${8128}$ est constante puisque ${8128}$ est parfait.
La suite aliquote de ${12496}$ est d’ordre $5$ : ${12496}$, ${14288}$, ${15472}$, ${14536}$, ${14264}$, ${12496}$. C’est le nombre social d’ordre le plus petit après les nombres parfaits et les nombres amicaux. Il a été découvert par Paul Poulet² en 1918. Une conjecture énonce qu’il n’existe pas de chaîne sociable d’ordre $3$. Elle n’a pas reçu à ce jour de démonstration.
La suite aliquote de ${14316}$ aboutit à une chaîne sociable après vingt-huit itérations.
La suite aliquote de ${2856}$ aboutit à une chaîne sociable après cinquante-sept itérations.

En 2012, on avait dénombré deux-cent-douze chaînes sociables d’ordre $k>2$.

Un autre mathématicien belge, Eugène Catalan³, a énoncé une autre conjecture :

A-t-on ainsi fait le tour de la question ? Il semblerait que oui, autrement dit que Catalan ait raison. En fait, il semblerait plutôt que non et qu’on n’ait pas examiné toutes les possibilités. En effet, cinq nombres inférieurs à ${1000}$ posent problème et font exception. Les cinq nombres dit de Lehmer⁴ : $276$, $552$, $564$, $660$, $966$ ont des suites aliquotes qui se poursuivraient indéfiniment.

Jean-Paul Delahaye a classé les suites aliquotes en cinq catégories de la manière suivante :

La suite aliquote aboutit à un nombre premier et donc à $1$.
La suite aliquote aboutit à un nombre parfait et y stationne.
La suite aliquote aboutit à une paire de nombres amicaux et oscille ensuite entre les deux nombres amicaux.
La suite aliquote atteint un élément d’une chaîne sociable et y reste cantonnée.
La suite aliquote semble se poursuivre à l’infini.

Les cinq nombres de Lehmer ne sont pas les seuls candidats dont les suites aliquotes semblent se poursuivre indéfiniment. Entre ${1000}$ et ${2000}$, il y a les douze nombres dits de Godwin : ${1074}$, ${1134}$, ${1464}$, ${1476}$, ${1488}$, ${1512}$, ${1560}$, ${1578}$, ${1632}$, ${1734}$, ${1920}$, ${1992}$.

Et, grâce aux ordinateurs, on a comptabilisé à l’heure actuelle neuf-mille-deux-cent-neuf nombres inférieurs à ${1000000}$ susceptibles d’être dans le même cas ! Catalan est pardonné. Il n’avait pas d’autre calculateur que sa matière grise. Mais sans démonstration, qui sait ?…

Vous trouverez ici la version .py des scripts pour les essayer.

⋅⋅⋅⋅⋅⋅⋅⋅⋅⋅♦⋅⋅⋅⋅⋅⋅⋅⋅⋅⋅

André-Jean Glière est professeur de mathématiques en classe préparatoire à l’ÉSÉO (École Supérieure d’Électronique de l’Ouest) à Angers.

Jean-Paul Delahaye, Nombres amiables et suites aliquotes, Logique et calcul. Pour la science 292 Février 2002.↩
Paul Poulet (1887-1946) est un mathématicien belge connu pour ses travaux sur les grands nombres parfaits et amiables.↩
Eugène Catalan (1814-1894) est un mathématicien franco-belge spécialiste de la théorie des nombres.↩
Derrick Lehmer (1905-1991) est un mathématicien américain spécialisé dans la recherche des nombres premiers.↩

Pour citer cet article : Glière A.-J., « De surprenantes arithmétiques (fin ?)– André-Jean Glière », in APMEP Au fil des maths. N° 531. 24 juin 2019, https://afdm.apmep.fr/rubriques/recreations/surprenantes-arithmetiques-andre-jean-gliere/.

De surprenantes arithmétiques (fin ?)

André-Jean Glière

Nombres parfaits

Scripts Python

Nombres amicaux et suites aliquotes

Première généralisation : nombres amicaux

Scripts Python

Seconde généralisation : suites aliquotes

Script Python

Une réflexion sur « De surprenantes arithmétiques (fin ?)– André-Jean Glière »