Congruence des nombres premiers

Télécharger le projet
Commenter

Description

Le nombre x = (n+1)(n-1)(n-2)(n-3)(n-5)(n-7)(n-11)(n-13) est congru à 0 modulo(5806080) si n est un nombre premier quelconque. Ceci peut se démontrer assez facilement de manière élémentaire. Mais ceci n'est pas un contrôle de primalité. De nombreux nombres composés ont aussi la même propriété. A l'aide du programme ici présent on peut montrer que approximativement un quart des nombres composés ont cette propriété et que cette proportion augmente en allant vers les plus grands nombres entiers. On note en particulier qu'il y a 9592 nombres premiers et 90408 nombres composés entre 1 et 100000 parmi lesquels la propriété citée est observée 33984 fois et dans ce cas, elle est donc vraie pour 24392 nombres composés et elle est fausse pour les 66016 autres nombres composés. Il est facile d'en voir la proportion pour d'autres domaines.

Source : 

/****************************************************
*  Programme Congruence -  @author pgl10            *
*  x = (n+1)(n-1)(n-2)(n-3)(n-5)(n-7)(n-11)(n-13)   *
*  est congru à 0 modulo(5806080) si n est premier  *
****************************************************/

#include "BigInteger.hpp"
              
int main() {
    for(BigInteger nm=10; nm <= 100000; nm=nm*10) {
        BigInteger np=0, nc=0, nq, nr, nx=0;
        for(BigInteger n=1; n <= nm; n++) {
            BigInteger x = (n+1)*(n-1)*(n-2)*(n-3)*(n-5)*(n-7)*(n-11)*(n-13);
            // nq et nr : quotient et reste de la division x/5806080
            nq = x/5806080;
            nr = x-nq*5806080;
            // nx : nombre de fois où x est congru à 0 modulo(5806080)
            if(nr == 0) nx = nx+1;
            // np : nombre de nombres premiers entre 1 et nm
            if(isprembi(n)) {
                // Si n est premier x est congru à 0 modulo(5806080)
                if(nr != 0) std::cout << "nerreur !" << std::endl;
                np = np+1;
            }
            // nc : nombre de nombres composés entre 1 et nm
            else nc = nc+1;
        }
        // nk : nombre de nombres composés ayant x congru à 0 modulo(5806080)
        BigInteger nk = nx-np;
        std::cout << "nnm = " << nm << "   np = " << np << "   nc = " << nc 
                  << "   nx = " << nx << "   nk = " << nk << std::endl;
    }
    std::cout << std::endl;
    return 0;
}

Conclusion :

Les 10 premiers nombres composés ayant x congru à 0 modulo(5806080) sont : 1, 25, 35, 49, 55, 65, 77, 85, 91 et 95.

Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

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.

Du même auteur (pgl10)