Perché controlliamo fino alla radice quadrata di un numero primo per determinare se è primo?

Per verificare se un numero è primo o no, perché dobbiamo verificare se è divisibile solo fino alla radice quadrata di quel numero?

Se un numero nnon è un numero primo, può essere considerato in due fattori ae b:

n = a * b

Ora ae bnon può essere sia maggiore della radice quadrata di n, da allora il prodotto a * bsarebbe maggiore di sqrt(n) * sqrt(n) = n. Quindi, in qualsiasi fattorizzazione di n, almeno uno dei fattori deve essere più piccolo della radice quadrata di n, e se non riusciamo a trovare alcun fattore minore o uguale alla radice quadrata, ndeve essere un numero primo.

Diciamo m = sqrt(n)allora m × m = n. Ora, se nnon è un numero primo, npuò essere scritto come n = a × b, quindi m × m = a × b. Si noti che mè un numero reale mentre n, ae bsono numeri naturali.

Ora ci possono essere 3 casi:

1. a> m ⇒ b <m
2. a = m ⇒ b = m
3. a <m ⇒ b> m

In tutti i 3 casi, min(a, b) ≤ m. Quindi, se cerchiamo fino a m, siamo tenuti a trovare almeno un fattore di n, che è abbastanza per dimostrare che nnon è primo.

Perché se un fattore è maggiore della radice quadrata di n, l'altro fattore che si moltiplicherebbe con esso per uguagliare n è necessariamente inferiore alla radice quadrata di n.

Una spiegazione più intuitiva sarebbe: -

La radice quadrata di 100 è 10. Diciamo axb = 100, per varie coppie di a e b.

Se a == b, sono uguali e sono esattamente la radice quadrata di 100. Che è 10.

Se uno di questi è inferiore a 10, l'altro deve essere maggiore. Ad esempio, 5 x 20 == 100. Uno è maggiore di 10, l'altro è inferiore a 10.

Pensando a axb, se uno di questi si abbassa, l'altro deve diventare più grande per compensare, quindi il prodotto rimane a 100. Si muovono attorno alla radice quadrata.

La radice quadrata di 101 è circa 10.049875621. Quindi, se stai testando il numero 101 per la primalità, devi solo provare gli interi fino a 10, inclusi 10. Ma 8, 9 e 10 non sono essi stessi primi, quindi devi solo provare fino a 7, che è Prime.

Perché se c'è una coppia di fattori con uno dei numeri maggiori di 10, l'altro della coppia deve essere inferiore a 10. Se quello più piccolo non esiste, non esiste un fattore maggiore corrispondente di 101.

Se stai testando 121, la radice quadrata è 11. Devi testare gli interi primi da 1 a 11 (inclusi) per vedere se va in modo uniforme. 11 va in 11 volte, quindi 121 non è un numero primo. Se ti fossi fermato a 10 e non ne avessi provato 11, ne avresti perso 11.

Devi testare ogni numero intero maggiore di 2, ma inferiore o uguale alla radice quadrata, supponendo che stai testando solo numeri dispari.

`

Supponiamo che nnon sia un numero primo (maggiore di 1). Quindi ci sono numeri ae bcosì via

n = ab      (1 < a <= b < n)

Moltiplicando la relazione a<=bper ae botteniamo:

a^2 <= ab
 ab <= b^2

Pertanto: (notare che n=ab)

a^2 <= n <= b^2

Quindi: (Nota che ae bsono positivi)

a <= sqrt(n) <= b

Quindi se un numero (maggiore di 1) non è primo e testiamo la divisibilità fino alla radice quadrata del numero, troveremo uno dei fattori.

Supponiamo che il dato intero N non sia primo,

Allora N può essere fattorizzata in due fattori ae b, 2 <= a, b < Ntali che N = a*b. Chiaramente, entrambi non possono essere più grandi disqrt(N) simultaneamente.

Supponiamo che senza perdita di generalità a sia minore.

Ora, se non riesci a trovare alcun divisore di Nappartenenza nell'intervallo[2, sqrt(N)] , cosa significa?

Ciò significa che Nnon ha alcun divisore in [2, a]asa <= sqrt(N) .

Pertanto, a = 1e b = nquindi per definizione, Nè primo .

...

Ulteriori letture se non sei soddisfatto:

Molte diverse combinazioni di (a, b) possono essere possibili. Diciamo che sono:

(a ₁ , b ₁ ), (a ₂ , b ₂ ), (a ₃ , b ₃ ), ....., (a _k , b _k ). Senza perdita di generalità, assumere a _i <b _i ,1<= i <=k .

Ora, per essere in grado di dimostrare che Nnon è un numero primo, è sufficiente dimostrare che nessuno di un _io può essere ulteriormente fattorizzato. E sappiamo anche che a _i <= sqrt(N)e quindi è necessario controllare fino a sqrt(N)che coprirà tutto un _i . E quindi sarai in grado di concludere se è o meno Nprimo.

...

Sono davvero solo gli usi di base della fattorizzazione e delle radici quadrate.

Può sembrare astratto, ma in realtà sta semplicemente nel fatto che il massimo fattoriale possibile di un numero non primo dovrebbe essere la sua radice quadrata perché:

sqrroot(n) * sqrroot(n) = n.

Dato che, se un numero intero sopra 1e sotto o fino a si sqrroot(n)divide uniformemente in n, alloran non può essere un numero primo.

Esempio di pseudo-codice:

i = 2;

is_prime = true;

while loop (i <= sqrroot(n))
{
  if (n % i == 0)
  {
    is_prime = false;
    exit while;
  }
  ++i;
}

Quindi per verificare se un numero N è Prime o no. Dobbiamo solo verificare se N è divisibile per numeri <= SQROOT (N). Questo perché, se consideriamo N in uno qualsiasi dei 2 fattori, diciamo X e Y, vale a dire. N = X Y. Ognuno di X e Y non può essere inferiore a SQROOT (N) perché quindi, X Y <N Ognuno di X e Y non può essere maggiore di SQROOT (N) perché quindi X * Y> N

Pertanto un fattore deve essere minore o uguale a SQROOT (N) (mentre l'altro fattore è maggiore o uguale a SQROOT (N)). Quindi per verificare se N è Prime, dobbiamo solo controllare quei numeri <= SQROOT (N).

Supponiamo di avere un numero "a", che non è un numero primo [non significa numero primo / composito - un numero che può essere diviso equamente per numeri diversi da 1 o se stesso. Ad esempio, 6 può essere diviso uniformemente per 2 o per 3, nonché per 1 o 6].

6 = 1 × 6 o 6 = 2 × 3

Quindi ora se "a" non è un numero primo, allora può essere diviso per altri due numeri e diciamo che quei numeri sono "b" e "c". Che significa

a = b * c.

Ora se "b" o "c", ciascuno di essi è maggiore della radice quadrata di "a", la moltiplicazione di "b" e "c" sarà maggiore di "a".

Quindi, "b" o "c" è sempre <= radice quadrata di "a" per dimostrare l'equazione "a = b * c".

Per questo motivo, quando testiamo se un numero è primo o no, controlliamo solo fino alla radice quadrata di quel numero.

Dato un numero qualsiasi n , quindi un modo per trovare i suoi fattori è quello di ottenere la sua radice quadrata p:

sqrt(n) = p

Certo, se ci moltiplichiamo p da soli, torniamo indietro n:

p*p = n

Può essere riscritto come:

a*b = n

Dove p = a = b. Se aaumenta, quindi bdiminuisce per mantenerea*b = n . Pertanto, pè il limite superiore.

Aggiornamento: rileggo di nuovo questa risposta oggi e mi è diventato più chiaro. Il valore pnon significa necessariamente un numero intero perché se lo è, nnon sarebbe un numero primo. Quindi, ppotrebbe essere un numero reale (cioè con le frazioni). E invece di passare attraverso l'intera gamma di n, ora abbiamo solo bisogno di passare attraverso l'intera gamma di p. L'altra pè una copia speculare, quindi in effetti dimezziamo l'intervallo. E poi, ora sto vedendo che possiamo effettivamente continuare a rifare square roote farlo pper ulteriore metà della portata.

Sia n non primo. Pertanto, ha almeno due fattori interi maggiori di 1. Sia f il più piccolo di questi fattori. Supponiamo che f> sqrt n. Quindi n / f è un intero LTE sqrt n, quindi più piccolo di f. Pertanto, f non può essere il fattore più piccolo di n. Reductio ad absurdum; il fattore più piccolo di n deve essere LTE sqrt n.

Qualsiasi numero composto è un prodotto di numeri primi.

Diciamo n = p1 * p2, dove p2 > p1e sono numeri primi.

Se n % p1 === 0quindi n è un numero composto.

Se n % p2 === 0allora indovina anche cosa n % p1 === 0!

Quindi non c'è modo se, n % p2 === 0ma n % p1 !== 0allo stesso tempo. In altre parole, se un numero composto n può essere diviso equamente per p2, p3 ... pi (il suo fattore maggiore), deve essere diviso anche per il suo fattore più basso p1 . Si scopre che il fattore più basso p1 <= Math.square(n)è sempre vero.

Per testare la primalità di un numero, n , ci si aspetterebbe in primo luogo un ciclo come il seguente:

bool isPrime = true;
for(int i = 2; i < n; i++){
    if(n%i == 0){
        isPrime = false;
        break;
    }
}

Ciò che fa il ciclo sopra è questo: per un dato 1 <i <n , controlla se n / i è un numero intero (lascia il resto 0). Se esiste una i per cui n / i è un numero intero, allora possiamo essere sicuri che n non è un numero primo, a quel punto il ciclo termina. Se per no i, n / i è un numero intero, allora n è primo.

Come per ogni algoritmo, chiediamo: possiamo fare di meglio?

Vediamo cosa sta succedendo nel ciclo sopra.

La sequenza di i va: i = 2, 3, 4, ..., n-1

E la sequenza di controlli interi va: j = n / i, che è n / 2, n / 3, n / 4, ..., n / (n-1)

Se per alcuni i = a, n / a è un numero intero, allora n / a = k (numero intero)

oppure n = ak, chiaramente n> k> 1 (se k = 1, quindi a = n, ma non raggiungo mai n; e se k = n, quindi a = 1, ma inizio forma 2)

Inoltre, n / k = a, e come indicato sopra, a è un valore di i quindi n> a> 1.

Quindi, a e k sono entrambi numeri interi compresi tra 1 e n (esclusivo). Da allora, raggiungo ogni numero intero in quell'intervallo, in qualche iterazione i = a e in qualche altra iterazione i = k. Se il test di primalità di n fallisce per min (a, k), fallirà anche per max (a, k). Quindi dobbiamo controllare solo uno di questi due casi, a meno che min (a, k) = max (a, k) (dove due controlli riducono a uno) cioè, a = k, a quel punto a * a = n, che implica a = sqrt (n).

In altre parole, se il test di primalità di n dovesse fallire per alcuni i> = sqrt (n) (cioè, max (a, k)), allora fallirebbe anche per alcuni i <= n (cioè, min (a ,K)). Quindi, basterebbe eseguire il test per i = 2 a sqrt (n).