Serie degli inversi dei primoriali e fattoriali

La convergenza di una serie è un problema classico di matematica.

Un modo semplice per "sondare" la serie e stabilire se è convergente o divergente è quello di concentrarci sulla somma S della serie ed usare in PARI/GP le funzionalità suminf oppure sum; in tal modo aumentando il numero di elementi considerati si ha una indicazione sulla serie e la somma S.

In alcuni altri casi la sola suminf o la sum non è sufficiente e occorre scrivere un piccolo programma.

Primoriali

Un primoriale p# è uguale al prodotto dei numeri primi, a partire da p, con tutti i numeri primi precedenti.

Se vogliamo avere una indicazione sulla somma S della serie degli inversi dei primoriali,
possiamo scrivere il seguente programma:

SerRevPrimorial(n) = local(S=0,P=1);{

 forprime(i=2,n,
     P = ProdPrime(i);
     S = S + (1/P) * 1.0;
 );
 return(S);
}

ProdPrime(v)= local(p=1);{

 forprime(i=2,v,
          p = p * i;
 );
 return(p);
}

Se lo eseguiamo, otteniamo:

? SerRevPrimorial(1)
%35 = 0
? SerRevPrimorial(2)
%36 = 0.5000000000000000000000000000
? SerRevPrimorial(3)
%37 = 0.6666666666666666666666666667
? SerRevPrimorial(5)
%38 = 0.7000000000000000000000000000
? SerRevPrimorial(7)
%39 = 0.7047619047619047619047619047
? SerRevPrimorial(11)
%40 = 0.7051948051948051948051948052
? SerRevPrimorial(100)
%41 = 0.7052301717918009651474316828
? SerRevPrimorial(1000)
%42 = 0.7052301717918009651474316828
? SerRevPrimorial(10000)
%43 = 0.7052301717918009651474316828

Si osserva che già da p=7 si ottiene che la serie degli inversi dei primoriali converge al valore
0.7047619047619047619047619047, valore leggermente minore della metà della radice quadrata di 2 o del seno di Pigreco/4.


Fattoriali
Se vogliamo, invece, avere indicazioni sulla serie inversa dei fattoriali il programmino è del tipo:

SerRevFactorial(n) = local(S=0,P=1);{

 for(i=0,n,
     P = i!;
     S = S + (1/P) * 1.0;
 );
 return(S);
}

Dobbiamo tenere conto anche che 0!=1.

Se lo eseguiamo, otteniamo:

? SerRevFactorial(0)

%4 = 1.000000000000000000000000000

? SerRevFactorial(1)

%5 = 2.000000000000000000000000000

? SerRevFactorial(2)

%6 = 2.500000000000000000000000000

? SerRevFactorial(3)

%7 = 2.666666666666666666666666667

? SerRevFactorial(4)

%8 = 2.708333333333333333333333333

? SerRevFactorial(7)

%9 = 2.718253968253968253968253968

? SerRevFactorial(1000)

%10 = 2.718281828459045235360287471

Anche qui la serie converge ad un valore già da n=7, ovvero al valore 2.7182818284590452353602874712
che è il numero di Nepero e.

Alla prox

Persiani amichevoli

Persiani amichevoli

Esiste un legame tra numeri primi e numeri amicabili? Abbiamo visto che i numeri primi hanno solo due divisori diversamente da una coppia di numeri amicabili.

Un quesito: Un numero amicabile è solo pari? Sapreste dimostrare se è vero o falso?

Mentre meditate, vi dico che sicuramente un numero amicabile è composto, perchè ammette un numero di divisori maggiore di 2 e, quindi, scomponibile in numeri primi.

Altra domanda: dati tre numeri primi p,q,r possiamo ottenere dei numeri amicabili?

Al-Faris, vissuto in Persia attorno al 1300, nel suo testo sulle coppie amicabili, fornì la coppia (2^k)pq, (2^k)r, che è amicabile se e solo se:

p = (3*(2^(k-1)))-1,
q = (3*(2^k))-1
r = 9*(2^(2k-1))-1

sono tutti numeri primi, per k maggiore o uguale a 2.

E' evidente, per la definizione di Al Faris su come trovare i numeri amicabili tramite tre primi, che si tratta di potenze di 2 (pari) moltiplicate per dei dispari, il cui risultato è obbligatoriamente un pari.

Se si fissa k=2, si ottiene ad esempio p=5, q=11, r=71 tutti primi e quindi la coppia amicabile 220 e 284.

Per vedere quali coppie di numeri sono amichevoli con p,q,r primi è possibile scrivere un programmino in PARI/GP o in MAXIMA. In realtà si potrebbe tentare anche di risolvere un sistema di equazioni.

Il metodo di Al-Faris però non dà tutte le coppie di numeri amicabili, ma solo quelle ottenibili con le condizioni di cui sopra (vedi lista amichevoli noti http://amicable.homepage.dk/knwnc2.htm).

Ad esempio sono amichevoli anche le coppie (1184,1210) (2620,2924) (5020,5564) (6232,6368) che storicamente furono trovate da Eulero. Oggi il totale di coppie note, grazie ai computer è notevole: un totale di circa 11994387 coppie e si continua a trovarne altre.

Ecco un semplice programma in PARI/GP che sfrutta l'algoritmo di Al-Faris.
Samic(n1=2, n2=1000)=local();{
 if( n1<2, error("deve essere n1>=2"););
 for(k=n1,n2,
     p=(3*(2^(k-1)))-1;
     q=(3*(2^(k)))-1;
     r=(9*(2^(2*k-1)))-1;
     if(isprime(p) & isprime(q) & isprime(r) == 1,
         N=(2^k)*(p*q);
         M=(2^k)*r;
         print("(",N,",",M,")");
     );
 );  
 print("Numeri esaminati ", n2-n1+1 );
 return;
}

Ecco cosa fornisce con k tra 2 e 1000:
(220,284)
(17296,18416)
(9363584,9437056)
 
Vi do adesso la risposta al quesito iniziale: è falso. Esistono anche coppie di numeri amichevoli dispari e coppie di numeri amichevoli pari; ma non si trovano miste, ovvero uno pari e l'altro dispari. E' dimostrabile?
La lascio a voi la dimostrazione. Un suggerimento: partite dalla somma dei divisori (escluso se stesso) di un numero amichevole pari; che cosa vi da e perchè?

Altre osservazioni

1. Nessun numero amichevole è un quadrato

2. Esistono coppie di numeri amichevoli la cui somma delle cifre è uguale (mod 9); esempio: 

    (69615,87633)  da cui  6+9+6+1+5 = 27 e 8+7+6+3+3 = 27

     il mod 9 = 0 per entrambi

3. Esistono coppie amichevole che ogni numero è divisibile per la somma delle sue cifre; esempio:

    (2620, 2924). Qui 2+6+2+0=10 difatti 2610 è divisibile per 10; mentre 2+9+2+4=17 e 2924 è 

    divisibile per 17. Un numero divisibile per la somma delle sue cifre è detto Harshad number; 

    per cui la coppia amichevole è una Harshad amicable pair (HsAP).

    Esempi sono le coppie:

     (2620, 2924)

     (10634085,14084763),
     (23389695, 25132545),
     (34256222, 35997346)
     etc.

4 Spesso i numeri amichevoli di una coppia terminano con 0 e 5.

5 Il rapporto minimo n/m con n minore di m è tra 0.598343 e

  0.999999999999999999999999999999999999999999999999999999999999999999999999999999999999999998

6. Un Happy number è un numero tale che prendendo il quadrato delle sue cifre e sommandole e iterando il 

     processo si ottiene alla fine 1. Ad esempio prendiamo 7, si ottiene la sequenza:

     7,7x7=49,4x4+9x9=97,9x9+7x7=130,1x1+3x3=10,1x1=1.

     Le coppie di numeri amichevoli che sono costituite da Happy number sono definite Happy amicable 

    pair  (HyAP)

     Esempi sono le coppie:
 

     (10572550, 10854650),
     (32685250, 34538270),
     (35361326, 40117714),
     (35390008, 39259592)

     etc.

Algoritmo che cerca tutti i numeri amichevoli
Un algoritmo semplice che cerca, invece, tutti i numeri amichevoli può essere come quello che segue

Allamic(n1=2, n2=1000)=local(s=0, prec1=0);{
 if( n1<2, error("deve essere n1>=2"););
 for(k=n1,n2,
     s=AlqSum(k);
     if( AlqSum(s) == k && k! = s & k != prec1,
         print("(",k,",",s,")");
         prec1=s;
    );
    
 );  
 print("Numeri esaminati ", n2-n1+1 );
 return;
}

AlqSum(n)=local(ret=1);{
 vec = divisors(n);
 ret = sum(i=1, length(vec)-1, vec[i] );
 return(ret);
}

Alla prox.

Parti aliquote e successioni aliquote

Parti aliquote e successioni aliquote

Definiamo con s(n) la somma dei divisori (parti aliquote) di n, escluso n.

Si definisce n numero perfetto se s(n) = n, oppure numero abbondante se s(n)>n, difettivo se s(n)<n

Si definisce "successione aliquota", invece, la successione dei valori di s(x), arrestandosi a s(x)=0,che si ottiene nel seguente modo:

s(n) = k
s(k) = m
s(m) = ... etc

Esempio
s(15)=1+3+5=9, s(9)=1+3=4,s(4)=1+2=3,s(3)=1,s(1)=0

Nota: L'arresto a s(x)=0 è perchè infiniti numeri sono divisibili per 0.
 
Classi di comportamento
Ogni successione aliquota potenzialmente potrebbe ricadere in una delle seguenti classi di comportamento:
1. termina a 0
2. finisce in un ciclo, di lunghezza 1, di lunghezza 2 o maggiore
3. potrebbe crescere all'infinito

Successioni che terminano a 0
E' il caso dell'esempio di cui prima.

Successioni di lunghezza 1
I numeri perfetti hanno tale caratteristica. Ad esempio s(6)=6, s(28)=28, etc.

Congettura sui numeri perfetti
Si ipotizza che sono infiniti.

Successioni di lunghezza 2
I numeri amichevoli hanno questa caratteristica. Due numeri amichevoli a e b sono così definiti perchè la s(a)=b e s(b)=a.

Ad esempio la più piccola coppia di numeri amichevoli è (220,284).

Congettura sui numeri amichevoli
Si ipotizza che sono infiniti.

Liste di numeri amichevoli
http://djm.cc/amicable.txt
http://amicable.homepage.dk/knwnap.htm

Successioni di lunghezza maggiore di 2
 I numeri che danno luogo a sequenze di lunghezza maggiore di 2 sono detti numeri socievoli

Lista di numeri socievoli
http://djm.cc/sociable.txt

Congettura di Catalan e Dickson
Tale congettura ipotizza che tutte le sequenze aliquote a partire da un valore n intero  terminano nelle prime due classi di comportamento e mai crescendo all'infinito.

La congettura non è ancora provata e attualmente anche a livello di test al computer finora non si sono completamente testate tutte le situazioni. Ad esempio una di queste è n=276.

Recentemente si sta mettendo in dubbio la congettura, ovvero si è convinti, sempre come congettura da dimostrare, che in realtà anche la classe di comportamento 3 è possibile (vedi [GUY1977] R. K. Guy, Aliquot sequences, in Number Theory and Algebra (Academic Press, 1977).

Se vi va, trovate un controesempio e avrete posto fine alla congettura di Catalan e Dickson!

Problemi correlati
Sfruttando la tecnica delle parti aliquote e modificandone la funzione in gioco si possono costruire altri tipi di numeri.

Definiamo s+(n) = s(n) + 1 

Tutte le potenze di 2 sono di questo tipo e di lunghezza 1 (numeri quasi perfetti).
Esistono anche sequenze s+ di lunghezza 2, dette "coppie amichevoli quasi perfette"; mentre per lunghezze maggiore di 2 si parla di "numeri sociali quasi perfetti".

Vedi:
http://djm.cc/augmented.fmtlist
http://djm.cc/augsoc.fmtlist

Analogamente definiamo s-(n) = s(n) - 1

otterremo numeri definiti nel seguente modo:
numeri ridotti perfetti o quasi perfetti
numeri ridotti amichevoli o quasi amichevoli (o numeri fidanzati)
numeri ridotti socievoli o quasi socievoli

Vedi:
http://djm.cc/reduced.fmtlist
http://djm.cc/redsoc.fmtlist

Nuove ricerche da fare
Potremmo definire ancora altre funzioni non ancora indagate

s*k(n)          = s(n)*k
s/k(n)           = s(n)/k con k tale che il risultato sia intero
s*k+m(n)     = s(n)*k + m
s/k+m(n)      = s(n)/k + m
s^k(m)         = s(n)^k
s^k+m(n)     = s(n)^k + m

etc...
con k e m interi

Potreste provare a indagare sulle proprietà dei numeri in base a k e m e sulla sequenza.

Eccovi anche un algoritmo semplice con PARI/GP (da migliorare eventualmente) con cui un pò studiare le varie casistiche:

Alq(n,op="+",m=0,k=1) = local(ret=1, str="", str2="");{
 str = concat(str,n);
 str = concat(str,",");

 i = 0;
 retp = n;

 while(ret!= 0, 
       i++;
       vec = divisors(n);
       l = length(vec);
       retp2 = ret;
       ret = sum(i=1, l-1, vec[i] );
      
       if( op = "+", ret = ret*k + m; );
       if( op = "-", ret = ret*k - m; );
       if( op = "*", ret = ret*k + m; );
       if( op = "^", ret = ret^k + m; );

       if( retp == ret,   
           ret = 0;
       );
       if( retp2 == ret,
           retp2 = -1;
           if( retp2==-1, str=concat(str,ret); str=concat(str," cycle"););
           ret = 0;   
       );

       if( retp != ret & retp2 != -1,  
           if(ret==0,   str= concat(str,ret););
           if(ret!=0,   str= concat(str,ret); str=concat(str,","););
           n = ret;
       );
       
       if( ret==0 & retp2 != -1, str = concat(str," - len = "); str=concat(str,i));
       if( ret==0 & i==1 & retp2 != -1, str = concat(str," - perfect number"););
       if( ret==0 & i==2 & l > 2 & retp2 != -1, str = concat(str," - amicable number");); /* Not prime number */
       if( ret==0 & i>2 & retp2 != -1, str = concat(str," - sociable number"););      
 );
 print(str);
}


Ad esempio lanciabile come:
Alq(6)
Alq(12)
Individua i numeri perfetti, amicabili (escludendo i numeri primi) e i socievoli.

Sui cicli l'algoritmo lo potrete ovviamente migliorare perchè per semplicità quello presentato si arresta solo se due numeri consecutivi sono uguali, ma non individua sequenze ripetute con più di una cifra.

Ad esempio funziona con Alq(25) poichè si ripete 6, ma non funzionerebbe se si ripetono 4,7,2,4,7,2. Quindi va da voi migliorato.

Se invece si lancia con altre operazioni si possono ottenere cicli.
Ad esempio: Alq(12,"*",1,1) 

Se si vogliono gestire elevati numeri di cifre, conviene riscrivere il programma con GMP; altrimenti PARI/GP si interrompe laddove non è in grado di proseguire..

Alla prox