Puissances de nombres premiers

[Meiosis]

Bonjour,

J'aimerais une aide pour démontrer la conjecture suivante.

---
Soit un entier naturel supérieur à 1, l'indicatrice d'Euler de l'entier , la somme des diviseurs de l'entier et le n-ième nombre premier.

Considérons l'expression
On se concentre sur les cas pour lesquels .

Dans ces cas, il y aurait toujours 2 possibilités :

1) Soit A est premier
2) Soit A n'est pas premier et dans ces cas là; on calcule où est un nombre premier et k un entier naturel supérieur ou égal à 2.

La conjecture a été vérifiée jusqu'à n=52638812

Si n=52638812 on a A=10549870323 qui n'est pas premier mais

Ce que j'ai essayé de faire c'est que j'ai généralisé à la puissance k (par exemple ici k=6) et non plus seulement au carré de nombres premiers.

J'ai aussi essayé de démontrer cette conjecture, voici ma tentative :

, alors est un nombre premier. De plus, A est impair si et seulement si est positif et impair. Par conséquent est soit un nombre premier, soit la puissance d'un nombre premier

---

Merci à vous et bon dimanche.
-----

[Meiosis]

Petite coquille dans l'énoncé final de la conjecture.

C'est soit :

1) A est un nombre premier
2) est une puissance d'un nombre premier

[Meiosis]

Ma démonstration est fausse.
Quelqu'un peut-il m'aider ? Je ne vois pas par où commencer.

[MissJenny]

je me demande comment tu as fait pour trouver ça...

[A voir en vidéo sur Futura]

[Meiosis]

À l'intuition. Mais j'ai mis longtemps avant d'avoir une conjecture qui je pense est viable.

[MissJenny]

tu as une sacrée intuition! Déjà le lien entre n et P(n) est assez obscur, mais là il y a les fonction phi et sigma... (et le n+2 !)

[Biname]

Salut,
Je viens de passer le texte LaTeX du message #1 à une IA et lui ai demandé d'écrire le code vérifiant cette conjecture.
Le code tourne !!! et ???___semble__??? bon
Code python FWIW :

 Cliquez pour afficher

# GPT, j'ai juste modifié l'affichage, je n'ai pas tout analysé ???
def euler_indicator(n):
    result = n
    p = 2
    while p * p <= n:
        if n % p == 0:
            while n % p == 0:
                n //= p
            result *= (1.0 - (1.0 / p))
        p += 1
    if n > 1:
        result *= (1.0 - (1.0 / n))
    return int(result)

def sigma(n):
    divisors_sum = 0
    for i in range(1, n + 1):
        if n % i == 0:
            divisors_sum += i
    return divisors_sum

def is_prime(num):
    if num < 2:
        return False
    for i in range(2, int(num**0.5) + 1):
        if num % i == 0:
            return False
    return True

def verify_conjecture(limit):
    for n in range(2, limit + 1):
        phi_n = euler_indicator(n)
        sigma_n = sigma(n)
        P_n_plus_2 = 0 if n < 2 else [i for i in range(2, n * 10) if is_prime(i)][n + 1]
        A = phi_n + 1 if sigma_n - P_n_plus_2 >= 0 else phi_n + 1
        if A % 20 == 3:
            if (is_prime(A) or (sigma_n - P_n_plus_2) in [pow(p, k) for p in range(2, n * 10) if is_prime(p) for k in range(2, 10)]):
                print(f"Conjecture vérifiée pour n={n:>6}  A={A:>8}")
            else:
                print(f"Conjecture non vérifiée pour n={n:>6}    A={A:>8}")

# Test avec une limite
verify_conjecture(1000)

Ce code détecte ces contre-exemples pour 2<n<3000
Conjecture non vérifiée pour n= 361 A= 343
Conjecture non vérifiée pour n= 722 A= 343
Conjecture non vérifiée pour n= 2209 A= 2163

[MissJenny]

Salut,
Je viens de passer le texte LaTeX du message #1 à une IA et lui ai demandé d'écrire le code vérifiant cette conjecture.

qu'est-ce que ça veut dire? depuis quand un programme python permet de vérifier une conjecture de ce genre?

[pm42]

qu'est-ce que ça veut dire? depuis quand un programme python permet de vérifier une conjecture de ce genre?

Si tu avais lu la suite du message et pas simplement la 1ère ligne, tu saurais que ce genre de programme sert à trouver des contre-exemples.

[Meiosis]

Salut,
Je viens de passer le texte LaTeX du message #1 à une IA et lui ai demandé d'écrire le code vérifiant cette conjecture.
Le code tourne !!! et ???___semble__??? bon
Code python FWIW :

 Cliquez pour afficher

# GPT, j'ai juste modifié l'affichage, je n'ai pas tout analysé ???
def euler_indicator(n):
    result = n
    p = 2
    while p * p <= n:
        if n % p == 0:
            while n % p == 0:
                n //= p
            result *= (1.0 - (1.0 / p))
        p += 1
    if n > 1:
        result *= (1.0 - (1.0 / n))
    return int(result)

def sigma(n):
    divisors_sum = 0
    for i in range(1, n + 1):
        if n % i == 0:
            divisors_sum += i
    return divisors_sum

def is_prime(num):
    if num < 2:
        return False
    for i in range(2, int(num**0.5) + 1):
        if num % i == 0:
            return False
    return True

def verify_conjecture(limit):
    for n in range(2, limit + 1):
        phi_n = euler_indicator(n)
        sigma_n = sigma(n)
        P_n_plus_2 = 0 if n < 2 else [i for i in range(2, n * 10) if is_prime(i)][n + 1]
        A = phi_n + 1 if sigma_n - P_n_plus_2 >= 0 else phi_n + 1
        if A % 20 == 3:
            if (is_prime(A) or (sigma_n - P_n_plus_2) in [pow(p, k) for p in range(2, n * 10) if is_prime(p) for k in range(2, 10)]):
                print(f"Conjecture vérifiée pour n={n:>6}  A={A:>8}")
            else:
                print(f"Conjecture non vérifiée pour n={n:>6}    A={A:>8}")

# Test avec une limite
verify_conjecture(1000)

Ce code détecte ces contre-exemples pour 2<n<3000
Conjecture non vérifiée pour n= 361 A= 343
Conjecture non vérifiée pour n= 722 A= 343
Conjecture non vérifiée pour n= 2209 A= 2163

Malheureusement je crains que tu n'ais pas compris l'énoncé.
Pour n=361 on a qui n'est pas congru à 3 modulo 20.
Pour n=722 on a qui n'est pas congru à 3 modulo 20.
Pour n=2209 on a qui n'est pas congru à 3 modulo 20.

De toute façon la conjecture a été vérifiée jusqu'à n=52638812

[Meiosis]

Malheureusement je crains que tu n'ais pas compris l'énoncé.
Pour n=361 on a qui n'est pas congru à 3 modulo 20.
Pour n=722 on a qui n'est pas congru à 3 modulo 20.
Pour n=2209 on a qui n'est pas congru à 3 modulo 20.

De toute façon la conjecture a été vérifiée jusqu'à n=52638812

J'ai modifié le message précédent car il y avait quelques erreurs de notation.

[Biname]

Salut,
Le code qui vérifie la conjecture n'est pas très lourd, pourquoi ne le donnes-tu pas ?
La relecture du code python que je publie ci-dessus m'a montré une erreur P_n+2 était mal calculé
P_n+2 = sympy.prime(n+2)

Ce nouveau code donne un contre exemple en 680 ?

Conjecture non vérifiée pour n=   680    A=    3423  Facteurs premiers de A: {3: 1, 7: 1, 163: 1}
    P_682 = 5101, sigma(n) = 1620, phi(|P_682-sigma(n)|) = 3422

Nouveau code python tjrs FWIW :

 Cliquez pour afficher

from sympy import prime, isprime, factorint

def euler_indicator(n):
    result = n
    p = 2
    while p * p <= n:
        if n % p == 0:
            while n % p == 0:
                n //= p
            result *= (1.0 - (1.0 / p))
        p += 1
    if n > 1:
        result *= (1.0 - (1.0 / n))
    return int(result)

def sigma(n):
    divisors_sum = 0
    for i in range(1, n + 1):
        if n % i == 0:
            divisors_sum += i
    return divisors_sum

def verify_conjecture(limit):
    for n in range(2, limit + 1):
        P_n_plus_2 = prime(n + 2)
        sigma_n = sigma(n)
        phi_result = euler_indicator(abs(P_n_plus_2 - sigma_n))
        A = phi_result + 1

        if A % 20 == 3:
            if isprime(A) or (sigma_n - P_n_plus_2) in [pow(p, k) for p in range(2, n * 10) if isprime(p) for k in range(2, 10)]:
                #factors = factorint(A)
                #print(f"\nConjecture vérifiée pour n={n:>6}    A={A:>8}  Facteurs premiers de A: {factors}")
                #print(f"    P_{n+2} = {P_n_plus_2}, sigma(n) = {sigma_n}, phi(|P_{n+2}-sigma(n)|) = {phi_result}")
                pas_imprimer = 0
            else:
                factors = factorint(A)
                print(f"\nConjecture non vérifiée pour n={n:>6}    A={A:>8}  Facteurs premiers de A: {factors}")
                print(f"    P_{n+2} = {P_n_plus_2}, sigma(n) = {sigma_n}, phi(|P_{n+2}-sigma(n)|) = {phi_result}")

# Test avec une limite
verify_conjecture(1000)

Il reste à vérifier cette ligne
if isprime(A) or (sigma_n - P_n_plus_2) in [pow(p, k) for p in range(2, n * 10) if isprime(p) for k in range(2, 10)]:
On la complète ici en affichant les facteurs premiers de A

[Meiosis]

Salut,

pour n=680 on a :
3423 est congru à 3 modulo 20 mais n'est pas premier donc selon ma conjecture on calcule donc c'est bien la puissance d'un nombre premier.

[Biname]

Salut,
Cette fois le code vérifie la conjecture jusqu'à n = 10000
Il y avait une erreur dans le code précédent : si A n'est pas premier, il vérifiait que A est un carré.
Mon "assistant" a rendu plus lisible la ligne "dense" en créant une fonction is_power_of_prime(number):

 Cliquez pour afficher

# Temps de calcul pour n_max =  1000:  18 secondes
# Temps de calcul pour n_max = 10000: 288 secondes

from sympy import prime, isprime, factorint
import sys

def is_power_of_prime(number):
    for p in range(2, int(number**0.5) + 1):
        if isprime(p):
            k = 2
            while pow(p, k) <= number:
                if pow(p, k) == number:
                    return True
                k += 1
    return False

def euler_indicator(n):
    result = n
    p = 2
    while p * p <= n:
        if n % p == 0:
            while n % p == 0:
                n //= p
            result *= (1.0 - (1.0 / p))
        p += 1
    if n > 1:
        result *= (1.0 - (1.0 / n))
    return int(result)

def sigma(n):
    divisors_sum = 0
    for i in range(1, n + 1):
        if n % i == 0:
            divisors_sum += i
    return divisors_sum

def verify_conjecture(limit):
    for n in range(2, limit + 1):
        P_n_plus_2 = prime(n + 2)
        sigma_n = sigma(n)
        diff = P_n_plus_2 - sigma_n
        phi_result = euler_indicator(abs(diff))
        A = phi_result + 1
        s_A_prime = ""
        if isprime(A):
            s_A_prime = " A est premier"
        else:
            s_A_prime = " A non premier"
        print (f"n={n:>6}    A={A:>8}   {s_A_prime}")
        if A % 20 == 3:
            if isprime(A) or is_power_of_prime(diff):         # conjecture  OK
                factors = factorint(diff)
                print(f"Conjecture vérifiée pour n={n:>6}    A={A:>8}  Facteurs premiers de diff : {factors}")
                print(f"    P_{n+2} = {P_n_plus_2}, sigma(n) = {sigma_n}, phi(|P_{n+2}-sigma(n)|) = {phi_result}")
                pas_imprimer = 0    # permet de garder les print en commentaire

            else:                                             # contre-exemples
                factors = factorint(diff)
                print(f"Conjecture non vérifiée pour n={n:>6}    A={A:>8}  Facteurs premiers de diff : {factors}")
                print(f"    P_{n+2} = {P_n_plus_2}, sigma(n) = {sigma_n}, phi(|P_{n+2}-sigma(n)|) = {phi_result}")

# Test avec une limite
n_max = 100

verify_conjecture(n_max)

[Meiosis]

Salut,

Donc cette fois nous sommes d'accord : il n'y a pas de contre-exemple pour l'instant ?

Sais-tu quel niveau en mathématiques il faut avoir pour démontrer cette conjecture ?

Merci pour le code.

[Biname]

Sais-tu quel niveau en mathématiques il faut avoir pour démontrer cette conjecture ?

Aucune idée ! Ton niveau ne semble pas mauvais, c.a.d meilleur que le mien .

Merci pour le code.

Ce code est améliorable, entre autres is_power_of_prime(number) qui 'brute force', mon assistant te remercie.

[MissJenny]

Si tu avais lu la suite du message et pas simplement la 1ère ligne, tu saurais que ce genre de programme sert à trouver des contre-exemples.

donc pas à vérifier (j'avais lu la suite)

[Biname]

donc pas à vérifier (j'avais lu la suite)

C'est vrai, le mot "vérifier" pour chercher un contre-exemple est inexacte.

[VictimairW3b]

tu es de quel niveau d'étude l'auteur ?

[Meiosis]

Terminale S spé maths de 2010.

[Meiosis]

Bonjour,

Je me permets de remonter ce sujet car à ce jour je n'ai pas eu de démonstration.
J'aimerais au moins savoir de quel niveau est cette démo.

Merci à vous.

[gg0]

Bonjour.

Il y a plusieurs cas :
* La conjecture est fausse (il y a des contre exemples, mais pas pour les nombres étudiés)
* La conjecture est juste, mais indémontrable
* La conjecture est juste, mais sa démonstration est de très haut niveau, et personne ayant ce niveau ne l'a regardé (ça ne les intéresse pas)
* La conjecture est juste, elle a une démonstration élémentaire que personne n'a encore trouvé parmi ceux qui l'ont regardé

La formulation est suffisamment compliquée pour que les deux derniers cas soient possible, vu son peu d'intérêt.

Cordialement.