Autor Tema: Números primos: curiosidades

0 Usuarios y 1 Visitante están viendo este tema.

30 Marzo, 2024, 09:37 am
Respuesta #10

feriva

  • $$\Large \color{#a53f54}\pi\,\pi\,\pi\,\pi\,\pi\,\pi\,\pi$$
  • Mensajes: 11,334
  • País: es
  • Karma: +1/-0
  • Sexo: Masculino
Quería compartir un artículo sobre la República de Platón, donde unos matemáticos descifraron en el texto varios teoremas sobre la distribución de los números primos. Me ha parecido interesante por lo que feriva había comentado al principio sobre lo del primordial.

El artículo está aquí: https://www.researchgate.net/publication/226417480_Plato's_hidden_theorem_on_the_distribution_of_primes

Básicamente los teoremas son:

a) Sea $$3<p_i<p_{i+1}$$ siendo $$p_i, p_{i+1}$$ primos consecutivos. Entonces, cada entero $$r<p_{i+1}$$ divide a $$p_i!$$

b) si $$n>5$$, siendo un natural, entonces $$n!$$ es divisible por todos los naturales menores o iguales que $$n$$. Y también por todos los compuestos menores que $$2n$$

Luego hay cierta especulación con el 7!=5040.

Un saludo

Ah, es que eso son factoriales no primoriales; o sea, esto \( P! \), si p es el primo 5, por ejemplo, es factorial de cinco

\( P!=5!=5*4*3*2 \)

en cambio, el primoral de 5 es el producto de los primeros cinco primos y se escribe así \( P_{5}\# \)

\( P_{5}\#\text{=2*3*5*7*11} \)

Va a ser divisible por todos los primos que aparecen desde el primero hasta el último, pero no por números al cuadrado o potencias mayores que 1; yo me despisté en mi “conjetura”, no pensé despacio, me dio la impresión al no fijarme en los cuadrados.

\( P_{4}\#\text{=2*3*5*7} \)

como 4 es una potencia, mayor que 1, de uno de esos primos, pues no divide al producto.

En cambio, en el factorial sí, porque aparece el 4, aparecen todos los naturales menores que el “n” del factorial; así que todos ellos dividen al producto, al factorial.

Saludos.

30 Marzo, 2024, 09:36 pm
Respuesta #11

RDC

  • $$\Large \color{#5e8d56}\pi\,\pi\,\pi$$
  • Mensajes: 465
  • País: es
  • Karma: +0/-0
  • Nunca te creas a quién te hable del futuro
    • Privatum. Blog de ideas

En realidad, usando el factorial no hace falta que sea el cuadrado de ningún número en particular, basta con que sea un primo mayor que el factorial, pues siempre será coprimo con el factorial; pero yo mezclé ideas con lo tuyo y otras cosas y lo compliqué.
Eso sí, la resta tiene que ser menor que el factorial, igual que en lo que haces tú, para poder asegurar que ese coprimo es un primo.

No hace falta pensar tampoco en eso del mayor primo hasta “n” (hasta la mita), pues buscamos un primo mayor que el factorial, siempre va a ser coprimo con el factorial, por ser un primo mayor que cualquiera suyo, cualquiera de los que componen sus números.

Pero sigue siendo difícil (cuando el factorial tiene cientos de cifras) encontrar un primo que al hallar la diferencia, ésta sea más pequeña que el factorial, porque la cantidad de cifras va a tener que ser la misma, con una más va a quedar grande (con muchas cifras va a pasar eso salvo muy excepcionalmente). Y buscar un primo con la misma cantidad de cifras va a ser difícil con algo tan grande.


Correcto, también puede ser coprimo con el factorial para que nos dé un primo. Y eso es más facil.

Tomas el factorial que quieras, que está formado por un producto de primos, y le vas restando los números siguientes al factorial te dará, como yo he hecho antes, la lista completa de primos. O dicho de otro modo, si restas el factorial con un número más grande y obtienes un primo mayor que los que componen al factorial, entonces ese número más grande es coprimo con el factorial. Por tanto, posiblemente sea primo.

Otro ejemplo:

$$n=6, 6!=720$$

$$721-720=1$$ 721 es coprimo con 720, y por tanto con 2,3,5, que son los factores de 720
$$723-720=3$$ 723 es múltiplo de 3, dado que 3 es factor de 720
$$725-720=5$$ 725 es múltiplo de 5, dado que 5 es factor de 720
$$727-720=7$$ 727 es coprimo con 720 (además es primo)
$$729-720=9$$ 729 es múltiplo de 3.
$$731-720=11$$ 731 es coprimo con 720. No es primo, dado que es divisible entre 17 y 43.

Por tanto, si tienes un factorial, como 6!, cuyos factores son la siguiente lista de primos $$L_3=\left\{{2,3,5}\right\}$$ entonces sabes que sumando ese factorial al primer primo que no está en la lista (el 7) te dará un número coprimo con el factorial. Y ademas puede ser primo.

720+7=727. Es coprimo con 720 y además es primo.

Eso es facilísimo si tienes un factorial y tienes su lista de primos. Tomas el factorial, le sumas cualquier primo que sepas que seguro no tiene y te dará un coprimo suyo, que además puede ser primo.

De todas maneras, si con un coprimo te vale simplemente le sumas +1 al factorial y ya lo tienes. Además puede ser primo.

Citar

Te explicó mejor por qué se me cruzaron los cables.

Cuando tienes una secuencia de números naturales ordenados que llega hasta un “n”, existe un primo en dicha secuencia tal que \( p^{2}>n \), por lo que los compuestos hasta “n” serán todos múltiplos de ese “p”y de los más pequeños (no de todos a la vez, claro, de algunos, quiero decir que obligatoriamente todos los compuestos hasta “n” tendrán algún factor que será P ó menor que P; obligatoriamente todos los compuestos lo tendrán). Porque si tiene dos factores mayores que P, digamos x,y,entonces

\( xy>p^{2}>n \)

y así no puede estar dentro de la secuencia que va de 1 a “n” ningún compuesto mayor que el cuadrado de ese "p".

Puede estar a lo mejor x como factor, pero acompañado de uno de los menores que “p”, puede ser “qx” menor que “n”.

Y esto no tiene nada que ver con lo que decía, se me cruzaron las ideas al ver que usabas el cuadrado.

Esto sirve para encontrar primos de una forma cómoda, para eliminar posibilidades considerando números menores que la raíz cuadrad de “n” que puedan dividir a “n”, para saber si “n” es primo o no (por lo explicado).

Por ejemplo, si quiero saber si 23 es primo, la raíz de 23 es menor que 5 (dicho de otra manera, 5²>23) así que de ser compuesto tendría que estar formado por algún factor menor que 5, o seá, 3 ó 2; y rápidamente se ve que no es divisible por 2 ni por 3, luego es primo.

Buenas noches.

Pues, sí,  lo establezco por esta misma razón que tu dices. Pero no lo dije para no hacerlo más lioso.

Este que cuentas es un teorema muy antiguo: 

Dado un natural cualquiera $$n$$ para saber cuál es su mayor factor primo posible, $$p_m$$, basta con $$p_m\leq{\sqrt[ ]{n}}$$.

Sobre él tengo un intento de demostración de la conjetura de Andrica. Más tarde la colgaré a ver que te parece.
Nunca nadie comprende nada exactamente de la misma manera

31 Marzo, 2024, 09:35 am
Respuesta #12

vmanalb

  • $$\Large \color{#5372a0}\pi\,\pi$$
  • Mensajes: 82
  • País: es
  • Karma: +0/-0
    • Víctor Manzanares Alberola
5^2+6*7*11*13)^101=;{-=4;-=2...}
7^2+5*6*11*13)^100=:{-2;-4;}
11^2+5*7*6*13)^101=;{-4;-2;...}
13^2 +...

Si coinciden en estas seties son potencialmente primo.
Siguiendo la serie para que.
n-(n/5-5^2+n/7-7^2+...) aprox n/ln(n)

Es decir 25:-2;-4;-2:-4:.....-2,-2,1

Podemos obtener los primos con facilidad coste lineal, entre comillas,  seria el truco de la tabla hash que la ciencia dice es lineal y yo digo que son tontos pero el tonto soy yo que no entiende algo que entiende todo el mundo .


31 Marzo, 2024, 11:53 am
Respuesta #13

RDC

  • $$\Large \color{#5e8d56}\pi\,\pi\,\pi$$
  • Mensajes: 465
  • País: es
  • Karma: +0/-0
  • Nunca te creas a quién te hable del futuro
    • Privatum. Blog de ideas
$$5^2+6*7*11*13)^{101}=;{-=4;-=2...}$$
$$7^2+5*6*11*13)^{100}=:{-2;-4;}$$
$$11^2+5*7*6*13)^{101}=;{-4;-2;...}$$
$$13^2 +...$$

si coinciden en estas seties son potencialmente primo.
siguiendo la serie para que.
$$n-(n/5-5^2+n/7-7^2+...) aprox n/ln(n)$$

es decir $$25:-2;-4;-2:-4:.....-2,-2,1$$

podemos obtener los primos con facilidad coste lineal, entre comillAS,  seria el truco de la tabla hash que la ciencia dice es lineal y yo digo que son tontos pero el tonto soy yo que no entiende algo que entiende otodo el mundo .

No entiendo muy bien qué operación es esta que pones: $$5^2+6*7*11*13)^{101}=;{-=4;-=2...}$$

Por tanto no entiendo qué significa esto que dices: $$25:-2;-4;-2:-4:.....-2,-2,1$$
Nunca nadie comprende nada exactamente de la misma manera

08 Abril, 2024, 01:24 pm
Respuesta #14

vmanalb

  • $$\Large \color{#5372a0}\pi\,\pi$$
  • Mensajes: 82
  • País: es
  • Karma: +0/-0
    • Víctor Manzanares Alberola
Disculpa soy un capullo. pero buen tio.

lo paso en C solo un trozo, y link al archivo.

si no lo entiendes, es C , lo explico en palabras , bueno paso casi todo el codigo por el tema de saber que hay en memoria del calculo que describo
#include <stdio.h>
#include <omp.h>
#include <stdlib.h>
#include <sched.h>
#include <stdbool.h>
#include <enmintrin.h>

int main() {
    long long n =30;
    long long max=n*n;
    long long m =0;
    int num_threads=10;

    double start_time6, end_time6;
    bool *P6 = (bool *) malloc((n + 1-m) * sizeof(bool));
    int *Secuencia= (long long*) malloc((cantidad)* sizeof(long long));
    if (P6 == NULL) {
        printf("Error al asignar memoria dinámica en primos.\n");
        free(P6);
        return 1;
    }
    if (Secuencia== NULL) {
        printf("Error al asignar memoria dinámica en Secuencia.\n");
        free(P6);
        return 1;
    }
    P6[2] = 1;
    P6[3] = 1;
    P6[5] = 1;
    P6[7] = 1;

    for (int i = 6; i <= n; i = i + 6) {
        P6[5 + i] = 1;
        P6[7 + i] = 1;
        P6[2 + i] = 0;
        P6[3 + i] = 0;
        P6[4 + i] = 0;
    }

    for (int i = 5; i <= n^(1/2); i = i + 2) {
        int salto=2 * i;
        int salto2=4 * i;
        if(P6==1){
            for (int j = i * i; j <= n; j += salto2) {
                P6[j] = 0;
                j += salto;
                P6[j] = 0;
            }
        }
        i += 4;
        if(P6==1){
            for (int j = i * i; j <= n; j += salto) {
                P6[j] = 0;
                j += salto2;
                P6[j] = 0;
            }
        }
    }
    printf("lista de primos hasta raiz de max, metodo viejo.");

    for (long long i = m; i <= n; i++) {
        printf("%d es %lld\n", P6[i-m], i);
    }
    printf("comienzo del calculo\n");
    for (long long i=0;i<=n;i++){
        Secuencia=2;
        i++;
        Secuencia=4;
    }

    int c =0;
    printf("busco el ultimo primo en raiz\n");
    while (P6[n-c]==0){
        c++;
    }
    long long ultimo=(n-c);
    printf("%lld",ultimo);
    printf("cuento los primos");
    long long cantidad=0;
    for (int cant=0;cant<=n;cant++){
        if(P6[cant]==1){
            cantidad++;
        }
    }

    for(long long pos=0;pos<=n;pos++){
        if (P6[pos]==1){
            Secuencia[cant]=pos;
            cant++;
        }
    }
    long  *SecuenciaMP= (int*) malloc((cantidad)* sizeof(long));

    for (long long pos=0;pos<=cantidad;pos++){
        SecuenciaMP[cant2]=(ultimo*ultimo)%secuencia[pos];
    }

    for (long long i = 0; i < cantidad; i++) {
        for (long long j = i + 1; j < cantidad; j++) {
            if (SecuenciaMP > SecuenciaMP[j]) {
                long long temp = SecuenciaMP;
                SecuenciaMP = SecuenciaMP[j];
                SecuenciaMP[j] = temp;
            }
        }
    }

    long long obj=0;
    long long s;
    long long o;
    long long primo;
    long long recal;
    long long limite = ultimo*ultimo;
    for (sec=2;sec<=limite;sec+=2){
        if (SecuenciaMP[obj]==sec){
            if(sec>recal){recal=sec;}
           for(long long sx=0;sx<=recal;sx++){
                if (SecuenciaMP[sx]<=SecuenciaMP[recal +1])   
                    obj=sx;
            }
              SecuenciaMP[sec]=secuencia[sec]*6;           
        }else{
            primo=limite-sec;
            printf("%lld es primo\n",primo);
        }
        sec+=4;
        if (SecuenciaMP[obj]==sec){
            if(sec>recal){recal=sec;}
           for(long long sx=0;sx<=recal;sx++){
                if (SecuenciaMP[sx]<=SecuenciaMP[recal +1])   
                    obj=sx;
            }         
            SecuenciaMP[sec]=secuencia[sec]*6;
        }else{
            primo=limite-sec;
            printf("%lld es primo\n",primo);
        }
    }

El calculo que describo corresponde a esto :

for (sec=2;sec<=limite;sec+=2){
        if (SecuenciaMP[obj]==sec){
            if(sec>recal){recal=sec;}
           for(long long sx=0;sx<=recal;sx++){
                if (SecuenciaMP[sx]<=SecuenciaMP[recal +1])   
                    obj=sx;
            }
              SecuenciaMP[sec]=secuencia[sec]*6;           
        }else{
            primo=limite-sec;
            printf("%lld es primo\n",primo);
        }
        sec+=4;
        if (SecuenciaMP[obj]==sec){
            if(sec>recal){recal=sec;}
           for(long long sx=0;sx<=recal;sx++){
                if (SecuenciaMP[sx]<=SecuenciaMP[recal +1])   
                    obj=sx;
            }         
            SecuenciaMP[sec]=secuencia[sec]*6;
        }else{
            primo=limite-sec;
            printf("%lld es primo\n",primo);
        }
    }

esto es como

25: no primo
25-2=23:primo
23-4=19primo
19-=17 primo
17-4=13=primo
13-11............

si empiezas en 49 solo fallas en 25 y 55,

si lo haces en n^2 solo fallas en los multiplos de primos menores a n

08 Abril, 2024, 02:09 pm
Respuesta #15

RDC

  • $$\Large \color{#5e8d56}\pi\,\pi\,\pi$$
  • Mensajes: 465
  • País: es
  • Karma: +0/-0
  • Nunca te creas a quién te hable del futuro
    • Privatum. Blog de ideas
Disculpa soy un capullo. pero buen tio.

lo paso en C solo un trozo, y link al archivo.

si no lo entiendes, es C , lo explico en palabras , bueno paso casi todo el codigo por el tema de saber que hay en memoria del calculo que describo
#include <stdio.h>
#include <omp.h>
#include <stdlib.h>
#include <sched.h>
#include <stdbool.h>
#include <enmintrin.h>

int main() {
    long long n =30;
    long long max=n*n;
    long long m =0;
    int num_threads=10;

    double start_time6, end_time6;
    bool *P6 = (bool *) malloc((n + 1-m) * sizeof(bool));
    int *Secuencia= (long long*) malloc((cantidad)* sizeof(long long));
    if (P6 == NULL) {
        printf("Error al asignar memoria dinámica en primos.\n");
        free(P6);
        return 1;
    }
    if (Secuencia== NULL) {
        printf("Error al asignar memoria dinámica en Secuencia.\n");
        free(P6);
        return 1;
    }
    P6[2] = 1;
    P6[3] = 1;
    P6[5] = 1;
    P6[7] = 1;

    for (int i = 6; i <= n; i = i + 6) {
        P6[5 + i] = 1;
        P6[7 + i] = 1;
        P6[2 + i] = 0;
        P6[3 + i] = 0;
        P6[4 + i] = 0;
    }

    for (int i = 5; i <= n^(1/2); i = i + 2) {
        int salto=2 * i;
        int salto2=4 * i;
        if(P6==1){
            for (int j = i * i; j <= n; j += salto2) {
                P6[j] = 0;
                j += salto;
                P6[j] = 0;
            }
        }
        i += 4;
        if(P6==1){
            for (int j = i * i; j <= n; j += salto) {
                P6[j] = 0;
                j += salto2;
                P6[j] = 0;
            }
        }
    }
    printf("lista de primos hasta raiz de max, metodo viejo.");

    for (long long i = m; i <= n; i++) {
        printf("%d es %lld\n", P6[i-m], i);
    }
    printf("comienzo del calculo\n");
    for (long long i=0;i<=n;i++){
        Secuencia=2;
        i++;
        Secuencia=4;
    }

    int c =0;
    printf("busco el ultimo primo en raiz\n");
    while (P6[n-c]==0){
        c++;
    }
    long long ultimo=(n-c);
    printf("%lld",ultimo);
    printf("cuento los primos");
    long long cantidad=0;
    for (int cant=0;cant<=n;cant++){
        if(P6[cant]==1){
            cantidad++;
        }
    }

    for(long long pos=0;pos<=n;pos++){
        if (P6[pos]==1){
            Secuencia[cant]=pos;
            cant++;
        }
    }
    long  *SecuenciaMP= (int*) malloc((cantidad)* sizeof(long));

    for (long long pos=0;pos<=cantidad;pos++){
        SecuenciaMP[cant2]=(ultimo*ultimo)%secuencia[pos];
    }

    for (long long i = 0; i < cantidad; i++) {
        for (long long j = i + 1; j < cantidad; j++) {
            if (SecuenciaMP > SecuenciaMP[j]) {
                long long temp = SecuenciaMP;
                SecuenciaMP = SecuenciaMP[j];
                SecuenciaMP[j] = temp;
            }
        }
    }

    long long obj=0;
    long long s;
    long long o;
    long long primo;
    long long recal;
    long long limite = ultimo*ultimo;
    for (sec=2;sec<=limite;sec+=2){
        if (SecuenciaMP[obj]==sec){
            if(sec>recal){recal=sec;}
           for(long long sx=0;sx<=recal;sx++){
                if (SecuenciaMP[sx]<=SecuenciaMP[recal +1])   
                    obj=sx;
            }
              SecuenciaMP[sec]=secuencia[sec]*6;           
        }else{
            primo=limite-sec;
            printf("%lld es primo\n",primo);
        }
        sec+=4;
        if (SecuenciaMP[obj]==sec){
            if(sec>recal){recal=sec;}
           for(long long sx=0;sx<=recal;sx++){
                if (SecuenciaMP[sx]<=SecuenciaMP[recal +1])   
                    obj=sx;
            }         
            SecuenciaMP[sec]=secuencia[sec]*6;
        }else{
            primo=limite-sec;
            printf("%lld es primo\n",primo);
        }
    }

El calculo que describo corresponde a esto :

for (sec=2;sec<=limite;sec+=2){
        if (SecuenciaMP[obj]==sec){
            if(sec>recal){recal=sec;}
           for(long long sx=0;sx<=recal;sx++){
                if (SecuenciaMP[sx]<=SecuenciaMP[recal +1])   
                    obj=sx;
            }
              SecuenciaMP[sec]=secuencia[sec]*6;           
        }else{
            primo=limite-sec;
            printf("%lld es primo\n",primo);
        }
        sec+=4;
        if (SecuenciaMP[obj]==sec){
            if(sec>recal){recal=sec;}
           for(long long sx=0;sx<=recal;sx++){
                if (SecuenciaMP[sx]<=SecuenciaMP[recal +1])   
                    obj=sx;
            }         
            SecuenciaMP[sec]=secuencia[sec]*6;
        }else{
            primo=limite-sec;
            printf("%lld es primo\n",primo);
        }
    }

esto es como

25: no primo
25-2=23:primo
23-4=19primo
19-=17 primo
17-4=13=primo
13-11............

si empiezas en 49 solo fallas en 25 y 55,

si lo haces en n^2 solo fallas en los multiplos de primos menores a n

Interesante ya lo probaré
Nunca nadie comprende nada exactamente de la misma manera

08 Abril, 2024, 03:58 pm
Respuesta #16

vmanalb

  • $$\Large \color{#5372a0}\pi\,\pi$$
  • Mensajes: 82
  • País: es
  • Karma: +0/-0
    • Víctor Manzanares Alberola
https://upvedues-my.sharepoint.com/:f:/g/personal/vmanalb_upv_edu_es/EoAWXH8r6L1LiTMd5kEJXx0BfvH1J9UVgJEHknRglMRlaA?e=cv2oQO

Buscábamos un profesor de informática y yo ayuda en mates sobre teoría de cribas, y ciertas cosas, para escribir unos artículos
 
El link es de los códigos y eso, son míos salvo lo de libros y documentación.