Минимальное покрытие базисов для проверки квадратичности остатков

11

Вызов

Найдите наименьшее покрытие базисов (например, модулей), наборы квадратичных вычетов которых можно проверить с помощью поиска в таблице, чтобы окончательно определить, является ли данное неотрицательное целое число n совершенным квадратом. Все основания должны быть меньше или равны квадратному корню из максимального значения n .

Ответ с наименьшим набором оснований для данной категории n выигрывает испытание. (Это означает, что потенциально может быть более одного победителя.) Категории n :

         Category       Maximum allowed n    Maximum allowed modulus/base
    -------------    --------------------    ----------------------------
     8-bit values                     255                              15
    16-bit values                   65535                             255
    32-bit values              4294967295                           65535
    64-bit values    18446744073709551615                      4294967295

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

В случае, если полные покрытия не найдены (что вполне вероятно для 32-битных и 64-битных категорий), победителем будет набор баз, который статистически или доказуемо исключает наибольший процент не квадратов (без неправильных отчетные квадраты как не квадраты). Смотрите ниже для обсуждения неполных обложек.

Фон

Во многих приложениях теории чисел возникает вопрос, является ли некоторое число n совершенным квадратом (0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100 и т. Д.). Один из способов проверить , является ли п квадрата является ли тест (√n) ² = п, то есть ли округленный вниз квадратный корень пола п , когда в квадрате, возвращает п . Например, floor (√123) ² = 11² = 121, что не равно 123, поэтому 123 не является квадратным; но этаж (√121) ² = 11² = 121, поэтому 121 является квадратным. Этот метод отлично работает для небольших чисел, особенно когда доступна аппаратная операция с квадратным корнем. Но для больших чисел (сотни или тысячи бит) это может быть очень медленно.

Другой способ проверить прямоугольность - исключить неквадраты с помощью таблиц квадратичных вычетов. Например, все квадраты в базе 10 должны иметь конечную цифру (в одном месте), равную 0, 1, 4, 5, 6 или 9. Эти значения образуют набор квадратичного остатка для базы 10. Так что если база -10 число оканчивается на 0, 1, 4, 5, 6 или 9, вы знаете, что оно может быть квадратным, и потребуется дополнительное обследование. Но если число base-10 заканчивается на 2, 3, 7 или 8, то вы можете быть уверены, что оно не является квадратным.

Итак, давайте посмотрим на другую базу. Все квадраты в базе 8 должны заканчиваться на 0, 1 или 4, что обычно составляет всего 3 из 8 вариантов, что означает 37,5% вероятности того, что случайное число может быть квадратным, или 62,5% вероятности того, что случайное число определенно не будет квадратным. Это гораздо лучшие шансы, чем дает основание 10. (И обратите внимание, что операция с модулем Base-8 - это просто логическая операция, в отличие от модуля Base-10, который делится на 10 с остатком.)

Есть ли еще лучшие базы? Ну да, на самом деле. База 120 имеет 18 возможностей (0, 1, 4, 9, 16, 24, 25, 36, 40, 49, 60, 64, 76, 81, 84, 96, 100 и 105), что составляет всего 15% шанс быть квадратным И база 240 еще лучше, с только 24 возможностями, что составляет всего 10% вероятности быть квадратным.

Но ни одна отдельная база не может окончательно определить прямоугольность (если только она не превышает максимальное число, которое тестируется, что в высшей степени нецелесообразно). Одна Одиночная база может только исключает прямоугольность; это не может окончательно проверить прямоугольность. Только тщательно отобранный набор оснований, работая вместе, может окончательно проверить прямоугольность в диапазоне целых чисел.

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

Пример правильного, но не минимального покрытия

Крышка 16-основание крышки {3, 4, 5, 7, 8, 9, 11, 13, 16, 17, 19, 23, 25, 29, 31, 37} достаточно для окончательного определения прямоугольности или непрямости все 16-битные значения от 0 до 65535. Но это не минимальное покрытие, потому что существует по крайней мере одно 15-базовое покрытие, которое также легко обнаружить. Фактически, вероятно, что существуют гораздо меньшие покрытия - возможно, всего с 6 или 7 основаниями.

Но для иллюстрации давайте посмотрим на тестирование значения n с использованием этого набора из 16 базовых покрытий. Вот наборы квадратичных вычетов для вышеуказанного набора базисов:

Base m   Quadratic residue table specific to base m
------   ----------------------------------------------------
   3     {0,1}
   4     {0,1}
   5     {0,1,4}
   7     {0,1,2,4}
   8     {0,1,4}
   9     {0,1,4,7}
  11     {0,1,3,4,5,9}
  13     {0,1,3,4,9,10,12}
  16     {0,1,4,9}
  17     {0,1,2,4,8,9,13,15,16}
  19     {0,1,4,5,6,7,9,11,16,17}
  23     {0,1,2,3,4,6,8,9,12,13,16,18}
  25     {0,1,4,6,9,11,14,16,19,21,24}
  29     {0,1,4,5,6,7,9,13,16,20,22,23,24,25,28}
  31     {0,1,2,4,5,7,8,9,10,14,16,18,19,20,25,28}
  37     {0,1,3,4,7,9,10,11,12,16,21,25,26,27,28,30,33,34,36}

Теперь давайте проверим число n = 50401, используя этот набор оснований, преобразовав его в каждую базу. (Это не самый эффективный способ проверки остатка, но его достаточно для пояснительных целей.) Здесь нас интересует 1-е место (отмечено в скобках ниже):

 Base                               "Digits" in base m
   m          m^9   m^8   m^7   m^6   m^5   m^4   m^3   m^2   m^1  ( m^0 )
 ----      -----------------------------------------------------------------
   3           2     1     2     0     0     1     0     2     0   (  1 ) ✓
   4                       3     0     1     0     3     2     0   (  1 ) ✓
   5                             3     1     0     3     1     0   (  1 ) ✓
   7                                   2     6     6     6     4   (  1 ) ✓
   8                                   1     4     2     3     4   (  1 ) ✓
   9                                         7     6     1     2   (  1 ) ✓
  11                                         3     4     9     5   ( 10 )
  13                                         1     9    12     3   (  0 ) ✓
  16                                              12     4    14   (  1 ) ✓
  17                                              10     4     6   ( 13 ) ✓
  19                                               7     6    11   ( 13 )
  23                                               4     3     6   (  8 ) ✓
  25                                               3     5    16   (  1 ) ✓
  29                                               2     1    26   ( 28 ) ✓
  31                                               1    21    13   ( 26 )
  37                                                    36    30   (  7 ) ✓

Таким образом, мы можем видеть, что в 13 из этих оснований остаток соответствует известному квадратичному вычету (назовите это «попаданием» в таблице), а в 3 из этих оснований остаток не соответствует известному квадратичному вычету (назовите это "скучать"). Все, что нужно - это 1 промах, чтобы понять, что число не является квадратом, поэтому мы могли бы остановиться на 11, но для наглядности мы рассмотрели все 16 баз здесь.

Пример неполного покрытия

Технически неполное покрытие - это не покрытие, но это не главное. Набор баз {7, 8, 11, 15} почти полностью охватывает все 8-битные значения n от 0 до 255, но не совсем. В частности, он неправильно определяет 60 и 240 как квадратные (это ложные срабатывания) - но он правильно идентифицирует все действительные квадраты (0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196 и 225) и не дает никаких других ложных срабатываний. Таким образом, это 4-набор, который почти успешен в качестве решения, но в конечном итоге терпит неудачу, потому что неполное покрытие не является допустимым решением.

Для 8-битного n набор баз {7, 8, 11, 15} является одним из двух наборов из 4 базисов, которые выдают две ошибки, и существует семь наборов из 4 базисов, которые выдают только одну ошибку. На самом деле не существует наборов из 4 базисов, которые формируют полное и точное покрытие 8-битных значений. Можете ли вы найти набор из 5 баз, которые не дают ошибок, правильно покрывая все 8-битные значения? Или тебе нужно 6 или больше? (Я знаю ответ для 8-битного n , но я не собираюсь его выдавать. Я не знаю ответа для 16-битного, 32-битного или 64-битного, и я верю, что даже 16-битный Битовый регистр невозможно решить с помощью поиска методом грубой силы. Решение 32-битных и 64-битных случаев, безусловно, потребует генетических, эвристических или других методов поиска.)

Комментарий о криптографически больших числах

Помимо 64-битных чисел - вплоть до сотен или тысяч двоичных цифр - именно здесь быстрая проверка на квадратность действительно оказывается наиболее удобной, даже если покрытие неполное (что, безусловно, будет для действительно больших чисел). Как такой тест может быть полезным, даже если он недостаточно решающий? Что ж, представьте, что у вас был чрезвычайно быстрый тест на прямоугольность, который работал правильно в 99,9% случаев и давал ложные отрицательные значения в оставшиеся 0,1% времени, и никогда не давал ложных положительных результатов. С помощью такого теста вы сможете определить непрямость числа почти мгновенно, а затем, в исключительных случаях нерешительности, вы сможете прибегнуть к более медленному методу для разрешения неизвестного другим способом. Это сэкономит вам немало времени.

Например, набор {8, 11, 13, 15} является правильным в 99,61% времени для 8-битных значений n от 0 до 255, является правильным в 95,98% времени для 16-битных значений n от 0 до 65535, и является правильным 95,62% времени для 24-битных значений n от 0 до 16777215. По мере того как n стремится к бесконечности, процент правильности для этого набора оснований уменьшается, но он асимптотически приближается и никогда не опускается ниже 95,5944% правильность.

Таким образом, даже этот очень маленький набор из 4 маленьких базисов полезен для почти немедленной идентификации около 22 из 23 произвольно больших чисел как неквадратных, что устраняет необходимость дальнейшей проверки этих чисел более медленными методами. Более медленные методы необходимо применять только в небольшом проценте случаев, которые нельзя исключить с помощью этого быстрого теста.

Интересно отметить, что некоторые 16-битные базы достигают более 95% сами по себе. Фактически, каждая из оснований ниже способна отсеять лучше, чем 97% всех чисел вплоть до бесконечности, поскольку не является квадратной. Набор квадратичных остатков для каждого из этих оснований может быть представлен в виде массива упакованных битов, используя только 8192 байта.

Вот 10 самых мощных отдельных баз менее 2 ^ 16:

 Rank   Base    Prime factorization       Weeds out
 ----   ------------------------------    ---------
  1.    65520 = 2^4 x 3^2 x 5 x 7 x 13      97.95%
  2.    55440 = 2^4 x 3^2 x 5 x 7 x 11      97.92%
  3.    50400 = 2^5 x 3^2 x 5^2 x 7         97.56%
  4.    52416 = 2^6 x 3^2 x 7 x 13          97.44%
  5.    61200 = 2^4 x 3^2 x 5^2 x 17        97.41%
  6.    44352 = 2^6 x 3^2 x 7 x 11          97.40%
  7.    63360 = 2^7 x 3^2 x 5 x 11          97.39%
  8.    60480 = 2^6 x 3^3 x 5 x 7           97.38%
  9.    63840 = 2^5 x 3 x 5 x 7 x 19        97.37%
 10.    54720 = 2^6 x 3^2 x 5 x 19          97.37%

Видите что-нибудь интересное, что общего у этих баз? Нет оснований думать, что они могут быть полезны в сочетании друг с другом (может быть, они есть, а могут и нет), но здесь есть несколько хороших подсказок относительно того, какие основы могут быть наиболее влиятельными для больших категорий чисел.

Побочный вызов: одна из самых влиятельных баз (если не самая большая) до 2 ^ 28 - 245044800, которая сама по себе может правильно отсеять 99,67% не квадратов, или около 306 из 307 случайных чисел, брошенных в нее. Вы можете найти в наиболее влиятельную единую базу менее чем 2 ^ 32?

связанные с

В следующих вопросах есть несколько очень хороших идей, которые тесно связаны, а также несколько приемов микрооптимизации для ускорения определенных операций. Хотя связанные вопросы конкретно не ставят своей целью найти самый сильный набор базисов, идея сильных базисов неявно занимает центральное место в некоторых из используемых здесь методов оптимизации.

Тодд Леман
источник
Как вы будете определять тай-брейк, если не будете проверять каждое число в данном диапазоне и подсчитывать, сколько всего проверок было сделано?
Мартин Эндер
Я посмотрю на мощность множества квадратичных вычетов для каждой базы. Например, 4 является лучшим основанием, чем 3, потому что только половина значений по модулю 4 являются квадратичными вычетами, тогда как две трети значений по модулю 3 являются квадратичными вычетами. Таким образом, 4 обладает большей способностью отсеивать числа раньше. Худшее основание - 2, потому что оно не может исключать любое число, а лучшее основание меньше 256 - 240, что позволяет исключить 90% чисел. Возможно, придется сделать выборку Монте-Карло для действительно больших баз.
Тодд Леман
Да, это имеет смысл. Но решите ли вы связь только по первой базе, вероятность которой отличается, или как вы будете вычислять эффективность всего набора на основе вероятностей? Я также думаю, что вероятности больше не являются независимыми, как только вы проверили другие базы.
Мартин Эндер
2
В случае больших n пробелов, я думаю, мне придется выбирать соотношение на основе общей оценочной эффективности, рассчитанной путем умножения вероятностей, предсказанных каждым набором вычетов. Например, основания {8,11,13,15} имеют вероятности 0,375, 0,545455, 0,538462 и 0,4 соответственно, которые умножаются на 0,044056. Вычитая из 1, это дает 0,955944, что очень близко согласуется с исчерпывающим результатом подсчета 95,62%, измеренным по всем n в [0,2 ^ 24-1].
Тодд Леман

Ответы:

7

Mathematica

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

bits = 8
Timing[
 maxN = 2^bits - 1;
 maxBase = 2^(bits/2) - 1;
 bases = {
     #,
     Union[Mod[Range[0, Floor[#/2]]^2, #]]
     } & /@ Range[3, maxBase];
 bases = SortBy[bases, Length@#[[2]]/#[[1]] &];
 numbers = {};
 For[i = 0, i <= Quotient[maxN, bases[[1, 1]]], ++i,
  AppendTo[numbers, # + i*bases[[1, 1]]] & /@ bases[[1, 2]]
  ];
 While[numbers[[-1]] > maxN, numbers = Most@numbers];
 numbers = Rest@numbers;
 i = 0;
 cover = {bases[[1, 1]]};
 lcm = cover[[-1]];
 Print@cover[[1]];
 While[Length@numbers > maxBase,
  ++i;
  bases = DeleteCases[bases, {b_, r_} /; b\[Divides]lcm];
  (*bases=SortBy[bases,(Print[{#,c=Count[numbers,n_/;MemberQ[#[[2]],
  Mod[n,#[[1]]]]]}];c)&];*)
  bases = SortBy[
    bases,
    (
      n = Cases[numbers, n_ /; n < LCM[#[[1]], lcm]];
      Count[n, n_ /; MemberQ[#[[2]], Mod[n, #[[1]]]]]/Length@n
      ) &
    ];
  {base, residues} = bases[[1]];
  numbers = Cases[numbers, n_ /; MemberQ[residues, Mod[n, base]]];
  AppendTo[cover, base];
  lcm = LCM[lcm, base];
  Print@base
  ];
 cover
 ]

Он решает 8 бит за короткое время со следующими 6 базами:

{12, 13, 7, 11, 5, 8}

16 бит занимает 6 с и приводит к следующему 6-базовому покрытию:

{240, 247, 253, 119, 225, 37}

Для более крупных случаев этот подход явно не хватает памяти.

Чтобы выйти за пределы 16 бит, мне нужно найти способ проверить, является ли покрытие завершенным, фактически не сохраняя список всех чисел до N max (или перейти к изучению теории чисел).

Редактировать: Уменьшено время выполнения для 16 битов с 66 до 8 секунд, предварительно заполнив список чисел только теми, которые не исключены самой эффективной базой. Это также должно значительно улучшить объем памяти.

Изменить: я добавил две незначительные оптимизации, чтобы уменьшить пространство поиска. Это не одна из официальных категорий, но с этим я нашел 8-базовую крышку на 24 бита за 9,3 часа:

{4032, 3575, 4087, 3977, 437, 899, 1961, 799}

Что касается оптимизаций, я теперь пропускаю все базы, которые делят LCM баз, уже находящихся в крышке, и когда я проверяю эффективность базы, я проверяю ее только по номерам до LCM этой новой базы и всех баз, которые я уже имею. имеют.

Мартин Эндер
источник
1
@ToddLehman Не знаю, видел ли ты мое первое решение до того, как я отредактировал его для жадного. (Посмотрите историю редактирования, если вы этого не сделали.) Там я просто выбирал базы по их общему соотношению попаданий / промахов, пока у меня не было полного покрытия. Это дало 8 баз для 8 бит и 29 баз для 16 бит. : D
Мартин Эндер
1
@ToddLehman Спасибо за тесты! :) Интересно, что могут придумать люди с фактическим знанием теории чисел. У меня есть пара идей, чтобы ускорить его, так что я могу перейти к 24 битам, но я думаю, что мне нужно сосредоточиться на том, чтобы подготовить свой следующий вызов на треке.
Мартин Эндер
1
@ToddLehman Для вас есть 24-битная обложка. Мне уже было интересно, смогу ли я использовать основные факторы, но я еще не придумал приличную эвристику. Все, что я мог сделать, это улучшить порядок, в котором тестируются базы, но я пока не уверен, когда смогу это прервать.
Мартин Эндер,
1
@ToddLehman Вам не нужно отмечать меня в моих собственных сообщениях, так как я все равно получу уведомление. Вот почему SE отключает автозаполнение, пока не появятся комментарии от нескольких пользователей, где может иметь смысл обратиться к OP.
Мартин Эндер
1
Только что нашли 9-основную крышку на 28 битов: {15840, 15827, 16211, 12549, 14911, 15111, 9869, 14647, 16043}. Время выполнения составило 36,5 минут с использованием программы на C, оптимизированной для оценки пригодности с использованием упакованных побитовых операций с использованием жадного алгоритма. Этот 9-базовый набор является идеальным прикрытием для чисел менее 2 ² and и с точностью 99,999983% для чисел в диапазоне 2..
Тодд Леман