La conjecture de sierpinski

Description

La conjecture de Sierpinski dit que :
5/d = 1/i +1/j +1/k
est toujours possible en nombre entiers. Cette conjecture n'est pas démontrée. Mais on ne connait aucun contre-exemple. Le programme présenté ici permet de vérifier cette conjecture pour la valeur donnée du dénominateur d, en utilisant pour la décomposition des nombres entiers compris entre 1 et une limite donnée. Avec la méthode utilisée ici, il est nécessaire d'employer des entiers sur 64 bits pour autoriser une limite supérieure à 950. Si on choisit une limite de 1000 le plus grand dénominateur possible sera de 1665. Toutefois 1664 et bien d'autres entiers plus petits n'ont pas de décomposition avec les entiers de l'intervalle 1 à 1000, mais ils en ont bien sûr avec un intervalle plus grand ! Parmi ces derniers c'est 73 le plus petit. Et bien sûr, beaucoup d'autres entiers plus petits que 1665 admettent une ou plusieurs décompositions dans cet intervalle. Ce programme permet de les calculer.

Source / Exemple :


#include <stdio.h>
#include <stdlib.h>
int main (){
__int64 maxint=9223372036854775807,ll,ln,ld,li,lj,lk;
int l,n,d,i,j,k,i1,im,jm,nd;
n=5;
printf("\n Conjecture de Sierpinski \n");
printf("\n En utilisant pour la d\202composition des nombres limit\x82s \x85 : ");
scanf("%d",&l);
ll=(__int64)l;
ln=(__int64)n;
if(ln*ll>maxint/(ll*ll)){
      printf("\n La limite est trop grande !\n\n"); 
      system("pause"); 
      return(1);
}
printf("\n Donnez le d\x82nominateur : ");
scanf("%d",&d);
if(!(d>1)) {
      printf("\n Il faut un d\x82nominateur > 1 !\n\n"); 
      system("pause"); 
      return(1);
}
ld=(__int64)d; nd=0;
i1=d/n; if(i1<1)i1=1;
im=1+(3*d-1)/n;
for(i=i1;i<=im;i++) {
      li=(__int64)i;
      if(n*i<=d) jm=l; else jm=2*d*i/(n*i-d); 
      if(jm>l) jm=l;
      for(j=i;j<=jm;j++){
            lj=(__int64)j;
            if(ln*li*lj!=ld*(li+lj))lk=ld*li*lj/(ln*li*lj-ld*(li+lj));
            if(ln*li*lj*lk==ld*(li*lj+lj*lk+lk*li)){
                  k=(int)lk;
                  if(k>=j&&k<=l){
                        printf("\n %d/%d = 1/%d + 1/%d + 1/%d",n,d,i,j,k); 
                        nd=nd+1;
                  }
            }
      }
}
printf("\n\n Avec les entiers de [1,%d] %d/%d a %d ",l,n,d,nd); 
if(nd<2) printf("d\202composition\n\n"); 
else printf("d\202compositions diff\x82rentes\n\n"); 
system("pause");
return(0);
}

Conclusion :


Vous pouvez faire des vérifications pour divers intervalles et divers dénominateurs.
Le plus grand intervalle utilisable ici est : [1,1226421].
Le nombre de décompositions obtenues est très variable.
Ici, 5/180 a 537 décompositions de Sierpinski et 5/181 en a 5 !
Toute remarque, amélioration ou signalement d'erreur sont bienvenus.

Codes Sources

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.