Почему мы проверяем квадратный корень из простого числа, чтобы определить, является ли оно простым?

Чтобы проверить, является ли число простым или нет, почему мы должны проверять, делится ли оно только до квадратного корня из этого числа?

Если число nне является простым, он может быть разложен на два фактора aи b:

n = a * b

Теперь aи bне может быть больше, чем квадратный корень из n, так как тогда продукт a * bбудет больше, чем sqrt(n) * sqrt(n) = n. Таким образом, в любой факторизации n, по крайней мере, один из факторов должен быть меньше квадратного корня из n, и если мы не можем найти какие-либо факторы, меньшие или равные квадратному корню, nдолжны быть простые числа.

Скажем m = sqrt(n)тогда m × m = n. Теперь, если nне простое число, то nможно записать как n = a × b, так m × m = a × b. Обратите внимание , что mдействительное число а n, aи bнатуральные числа.

Сейчас может быть 3 случая:

1. а> м ⇒ б <м
2. a = m ⇒ b = m
3. <м ⇒ б> м

Во всех 3 случаях min(a, b) ≤ m. Следовательно, если мы будем искать до m, мы обязательно найдем хотя бы один фактор n, которого достаточно, чтобы показать, что nон не прост.

Потому что, если коэффициент больше, чем квадратный корень из n, другой фактор, который будет умножаться на него, равный n, обязательно меньше, чем квадратный корень из n.

Более интуитивное объяснение будет:

Квадратный корень из 100 равен 10. Скажем, axb = 100, для различных пар a и b.

Если a == b, то они равны и являются квадратным корнем из 100, точно. Который 10.

Если один из них меньше 10, другой должен быть больше. Например, 5 x 20 == 100. Один больше 10, другой меньше 10.

Думая об оси, если один из них падает, другой должен увеличиться, чтобы компенсировать, поэтому продукт остается на уровне 100. Они вращаются вокруг квадратного корня.

Квадратный корень из 101 составляет около 10,049875621. Поэтому, если вы проверяете число 101 на простоту, вам нужно пробовать целые числа до 10, включая 10. Но сами по себе 8, 9 и 10 не являются простыми, поэтому вам нужно проверить только до 7, что премьер.

Потому что, если есть пара факторов с одним из чисел больше 10, другой из пары должен быть меньше 10. Если меньший не существует, не найден соответствующий больший фактор 101.

Если вы тестируете 121, квадратный корень равен 11. Вы должны проверить простые целые числа от 1 до 11 (включительно), чтобы убедиться, что они входят равномерно. 11 идет в 11 раз, поэтому 121 не простое число. Если бы вы остановились на 10 и не протестировали 11, вы бы пропустили 11.

Вы должны проверить каждое простое число больше 2, но меньше или равно квадратному корню, предполагая, что вы проверяете только нечетные числа.

`

Предположим, что nэто не простое число (больше 1). Так что есть цифры aи bтакие, что

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

Умножив отношение a<=bна aи bполучим:

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

Поэтому: (обратите внимание, что n=ab)

a^2 <= n <= b^2

Отсюда: (обратите внимание, что aи bположительны)

a <= sqrt(n) <= b

Поэтому, если число (больше 1) не является простым, и мы проверяем делимость до квадратного корня из числа, мы найдем один из факторов.

Давайте предположим, что данное целое число Nне является простым,

Тогда N можно разложить на два фактора aи b, 2 <= a, b < Nтаких, что N = a*b. Понятно, что они оба не могут быть больше, чем sqrt(N)одновременно.

Предположим без ограничения общности, что a меньше.

Теперь, если вы не смогли найти какой-либо делитель Nпринадлежности в диапазоне[2, sqrt(N)] , что это значит?

Это означает, что Nв [2, a]качествеa <= sqrt(N) .

Следовательно, a = 1и, b = nследовательно, по определению Nявляется простым .

...

Дальнейшее чтение, если вы не удовлетворены:

Многие различные комбинации (a, b)могут быть возможны. Допустим, они являются:

(a ₁ , b ₁ ), (a ₂ , b ₂ ), (a ₃ , b ₃ ), ....., (a _k , b _k ). Не ограничивая общности, предположим, что _I <Ь _I , 1<= i <=k.

Теперь, чтобы показать, что Nэто не простое число, достаточно показать, что ни одно из _{i не} может быть разложено дальше. И мы также знаем, что а _я <= sqrt(N)и, следовательно, вам нужно проверить, до sqrt(N)которого будет охватывать все _я . И, следовательно, вы сможете сделать вывод, действительно лиN является оно простым.

...

Это все на самом деле просто базовое использование факторизации и квадратных корней.

Это может показаться абстрактным, но на самом деле это просто связано с тем фактом, что максимально возможный факториал не простого числа должен быть его квадратным корнем, потому что:

sqrroot(n) * sqrroot(n) = n,

Учитывая, что если любое целое число выше 1и ниже или до sqrroot(n)делится поровну на n, тоn не может быть простым числом.

Пример псевдокода:

i = 2;

is_prime = true;

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

Итак, чтобы проверить, является ли число N простым или нет. Нам нужно только проверить, делится ли N на числа <= SQROOT (N). Это потому, что если мы разложим N на любые 2 множителя, скажем, X и Y, т.е. N = X Y. Каждое из X и Y не может быть меньше SQROOT (N), потому что тогда X Y <N Каждое из X и Y не может быть больше, чем SQROOT (N), потому что тогда X * Y> N

Поэтому один фактор должен быть меньше или равен SQROOT (N) (в то время как другой фактор больше или равен SQROOT (N)). Поэтому, чтобы проверить, является ли N простым, нам нужно проверить только эти числа <= SQROOT (N).

Допустим, у нас есть число «а», которое не является простым [не простое / составное число означает - число, которое может быть равномерно разделено на числа, отличные от 1 или самого себя. Например, 6 можно разделить равномерно на 2 или на 3, а также на 1 или 6].

6 = 1 × 6 или 6 = 2 × 3

Так что теперь, если «a» не является простым, то его можно разделить на два других числа, и скажем, что эти числа - «b» и «c». Что значит

а = Ь * с.

Теперь, если «b» или «c», любой из них больше квадратного корня из «a», чем умножение «b» и «c» будет больше, чем «a».

Таким образом, «b» или «c» всегда <= квадратный корень из «a», чтобы доказать уравнение «a = b * c».

По вышеуказанной причине, когда мы проверяем, является ли число простым или нет, мы проверяем только до получения квадратного корня из этого числа.

Учитывая любое число n, один из способов найти его факторы - получить квадратный корень p:

sqrt(n) = p

Конечно, если мы умножим pна себя, мы вернемся n:

p*p = n

Это может быть переписано как:

a*b = n

Где p = a = b. Если aувеличивается, то bуменьшается, чтобы сохранить a*b = n. Следовательно, pэто верхний предел.

Обновление: сегодня я перечитываю этот ответ снова, и он мне стал понятнее. Значение pне обязательно означает целое число, потому что если оно есть, то nоно не будет простым. Таким образом, pможет быть действительным числом (т. Е. С дробями). И вместо того, чтобы пройти весь диапазон n, теперь нам нужно пройти только весь диапазон p. Другой pявляется зеркальной копией, поэтому в действительности мы делим диапазон пополам. И затем, теперь я вижу, что мы можем фактически продолжать заново делать square rootи делать это, pчтобы увеличить половину диапазона.

Пусть n не простое число. Следовательно, он имеет по крайней мере два целых числа больше 1. Пусть f наименьший из n таких факторов. Предположим, что f> sqrt n. Тогда n / f является целым числом LTE sqrt n, таким образом, меньше, чем f. Следовательно, f не может быть наименьшим фактором n. Reductio ad absurdum; Наименьший коэффициент n должен быть LTE sqrt n.

Любое составное число является произведением простых чисел.

Скажем n = p1 * p2, где p2 > p1и они простые числа.

Если n % p1 === 0тогда n является составным числом.

Если n % p2 === 0тогда угадайте, что n % p1 === 0же!

Так что нет, если, n % p2 === 0но n % p1 !== 0в то же время. Другими словами, если составное число n может быть разделено равномерно на p2, p3 ... pi (его больший коэффициент), оно также должно быть разделено на его самый низкий коэффициент p1 . Оказывается, самый низкий фактор p1 <= Math.square(n)всегда верен.

Чтобы проверить простоту числа n , можно было бы ожидать цикл, такой как следующий:

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

Вышеприведенный цикл делает следующее: для данного 1 <i <n он проверяет, является ли n / i целым числом (оставляет остаток 0). Если существует i, для которого n / i является целым числом, то мы можем быть уверены, что n не является простым числом, и в этот момент цикл завершается. Если для нет i, n / i является целым числом, то n является простым.

Как и в случае с каждым алгоритмом, мы спрашиваем: можем ли мы добиться большего успеха?

Давайте посмотрим, что происходит в вышеуказанном цикле.

Последовательность i идет: i = 2, 3, 4, ..., n-1

И последовательность целочисленных проверок идет: j = n / i, то есть n / 2, n / 3, n / 4, ..., n / (n-1)

Если для некоторого i = a n / a является целым числом, то n / a = k (целое число)

или n = ak, очевидно, n> k> 1 (если k = 1, то a = n, но я никогда не достигну n; а если k = n, то a = 1, но я начинаю с формы 2)

Кроме того, n / k = a, и, как указано выше, a является значением i, поэтому n> a> 1.

Таким образом, a и k оба являются целыми числами от 1 до n (исключая). Так как я достигает каждого целого числа в этом диапазоне, на некоторой итерации i = a, а на другой итерации i = k. Если проверка простоты n не выполняется в течение min (a, k), она также не выполняется для max (a, k). Таким образом, нам нужно проверить только один из этих двух случаев, если только min (a, k) = max (a, k) (где две проверки сводятся к одному), т. Е. A = k, в этот момент a * a = n, что подразумевает a = sqrt (n).

Другими словами, если бы тест на простоту n был неудачным для некоторого i> = sqrt (n) (т. Е. Max (a, k)), то он также не прошел бы для некоторого i <= n (то есть min (a) , к)). Таким образом, будет достаточно, если мы запустим тест для i = 2 до sqrt (n).