Математика on kenji.blog

【Полное понимание через формулы】 Почему сильнейший классический «GNFS» проигрывает квантовым алгоритмам? Смена парадигмы в факторизации

Sun, 06 Sep 2026 12:00:00 +0900

Информационная безопасность в современном интернет-обществе защищена криптографией с открытым ключом, такой как RSA. Основа безопасности RSA опирается на тот факт, что “факторизация огромных составных чисел вычислительно крайне сложна” .

В этой статье мы раскроем математический механизм “Общего метода решета числового поля” (GNFS) — самого мощного алгоритма факторизации для классических компьютеров, и подробно разберем, почему он полностью побежден “Алгоритмом Шора” , открытым Питером Шором. Мы глубоко исследуем эту смену парадигмы с помощью математических формул и концептуальных схем.

1. Подход к факторизации в классических вычислениях: развитие метода факторизации Ферма

Задача факторизации — это задача поиска простых чисел $p, q$, таких что $N = p \times q$ для заданного составного числа $N$.

Основная идея сводится к поиску нетривиальных $x, y$, удовлетворяющих следующему сравнению:

$$ x^2 \equiv y^2 \pmod N $$

Если мы преобразуем это, то получим:

$$ x^2 - y^2 \equiv 0 \pmod N $$ $$ (x - y)(x + y) \equiv 0 \pmod N $$

Здесь, если $x \not\equiv \pm y \pmod N$, мы можем получить нетривиальный делитель $N$, вычислив $\gcd(x-y, N)$ или $\gcd(x+y, N)$. Этот факт лежит в основе современных алгоритмов факторизации, таких как GNFS.

2. Сильнейший классический алгоритм: Глубины “Общего метода решета числового поля” (GNFS)

“GNFS” — это самый быстрый алгоритм факторизации для классических компьютеров из известных на сегодняшний день. Его временная сложность требует субэкспоненциального (Sub-exponential) времени.

Сложность GNFS

Если предположить, что количество цифр $N$ равно $b = \log_2 N$, сложность GNFS может быть выражена следующим образом:

$$ O\left( \exp \left( \left(\frac{64}{9} b\right)^{1/3} (\log b)^{2/3} \right) \right) $$

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

Математический механизм GNFS

GNFS можно условно разделить на 4 этапа:

Выбор многочленов (Polynomial Selection)
Просеивание (Sieving)
Редукция матрицы (Matrix Reduction)
Вычисление квадратного корня (Square Root)

2.1. Выбор многочленов и алгебраическое числовое поле

Сначала выбираются неприводимые многочлены $f(x)$ и $g(x)$ с целыми коэффициентами. Они задаются так, чтобы иметь общий корень $m$ по модулю $N$. То есть:

$$ f(m) \equiv 0 \pmod N $$ $$ g(m) \equiv 0 \pmod N $$

Обычно $g(x)$ выбирается как многочлен первой степени $g(x) = x - m$. Если корень $f(x)$ обозначить как $\alpha$, образуется “алгебраическое числовое поле” (Number Field) $\mathbb{Q}(\alpha)$. Мы сравниваем операции в кольце $\mathbb{Q}(\alpha)$ и операции в обычном кольце целых чисел $\mathbb{Z}$ посредством гомоморфизма $\phi: \alpha \mapsto m$.

2.2. Просеивание (Sieving)

Далее мы ищем большое количество пар взаимно простых целых чисел $(a, b)$. Цель — найти такие пары, чтобы оба следующих значения были “B-гладкими” (B-smooth, то есть состоящими только из относительно малых простых множителей):

$a - bm$ (значение в кольце целых чисел)
$b^d f(a/b)$ (соответствует норме $N(a - b\alpha)$ в алгебраическом поле)

Здесь используется метод быстрого поиска, называемый “Решето” (Sieve). Это позволяет эффективно извлекать пары $(a, b)$, удовлетворяющие условиям, из огромного числа кандидатов.

2.3. Редукция матрицы (Linear Algebra over GF(2))

Из собранных пар $(a, b)$ мы формируем векторы показателей степени и находим левое нуль-пространство огромной разреженной матрицы над $\mathbb{F}_2$ (поле, содержащее только 0 и 1).

Мы находим вектор решения $v$ так, чтобы соотношения $ \prod (a_i - b_i m) $ и $ \prod (a_i - b_i \alpha) $ становились полными квадратами. Это не что иное, как решение системы линейных уравнений:

$$ M \mathbf{x} \equiv \mathbf{0} \pmod 2 $$

Здесь используются продвинутые алгоритмы численных вычислений, такие как алгоритм блочного Ланцоша (Block Lanczos) или блочного Видемана (Block Wiedemann).

2.4. Вычисление квадратного корня

Наконец, мы извлекаем квадратный корень как в алгебраическом числовом поле, так и в кольце целых чисел, что приводит к соотношению $x^2 \equiv y^2 \pmod N$. Затем мы вычисляем $\gcd(x-y, N)$ и получаем делитель.

3. Прорыв квантовых вычислений: “Алгоритм Шора”

В то время как GNFS требует субэкспоненциального времени, “Алгоритм Шора” , опубликованный Питером Шором в 1994 году, может решить эту задачу за “полиномиальное время” с использованием квантового компьютера.

Сложность Алгоритма Шора

Если предположить, что количество кубитов равно $O(\log N)$, то временная сложность составит:

$$ O((\log N)^3) $$

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

Обзор Алгоритма Шора: Сведение к задаче поиска периода

Алгоритм Шора искусно сводит задачу факторизации к “задаче поиска периода” .

Выберите случайное целое число $a$, взаимно простое с $N$ ($1 < a < N$).
Определите функцию $f(x) = a^x \bmod N$.
Найдите период $r$ функции $f(x)$, то есть наименьшее положительное целое число $r$ такое, что $a^r \equiv 1 \pmod N$.
Если $r$ четное, проверьте, не выполняется ли $a^{r/2} \not\equiv -1 \pmod N$, и вычислите $\gcd(a^{r/2} \pm 1, N)$ для получения простого делителя.

Этот шаг 3, то есть “нахождение периода $r$” , является узким местом, требующим экспоненциального времени на классическом компьютере. Однако квантовый компьютер решает это мгновенно, используя “квантовую суперпозицию” и “Квантовое преобразование Фурье” (QFT).

4. Квантовое преобразование Фурье (QFT) и извлечение периода

Давайте подробнее рассмотрим математические операции над квантовыми состояниями, которые лежат в основе Алгоритма Шора.

4.1. Генерация квантовой суперпозиции

Сначала подготовьте 2 квантовых регистра. Регистр 1 хранит состояние суперпозиции входных данных $x$, а регистр 2 хранит результат вычисления функции $f(x)$. Примените преобразование Адамара (Hadamard Transform) к начальному состоянию $|0\rangle |0\rangle$, чтобы создать суперпозицию всех возможных значений $x$.

$$ |\psi_1\rangle = \frac{1}{\sqrt{Q}} \sum_{x=0}^{Q-1} |x\rangle |0\rangle $$

(где $Q$ — это степень двойки, удовлетворяющая $N^2 \le Q < 2N^2$)

Далее используйте квантовый оракул $U_f$ для вычисления $f(x) = a^x \bmod N$ и сохраните результат в регистре 2.

$$ |\psi_2\rangle = U_f |\psi_1\rangle = \frac{1}{\sqrt{Q}} \sum_{x=0}^{Q-1} |x\rangle |a^x \bmod N\rangle $$

Предположим теперь, что регистр 2 измеряется (теоретически, даже если он не измеряется, математическая структура та же). Если наблюдается некоторое значение $y = a^{x_0} \bmod N$, состояние регистра 1 коллапсирует в суперпозицию всех $x$, удовлетворяющих $f(x) = y$. Если предположить, что период равен $r$, такие $x$ будут иметь вид $x_0, x_0 + r, x_0 + 2r, \dots$

$$ |\psi_3\rangle = \frac{1}{\sqrt{M}} \sum_{k=0}^{M-1} |x_0 + kr\rangle $$

(где $M \approx Q/r$ — количество членов)

Это состояние содержит информацию о периоде $r$, но прямое измерение даст лишь случайное $x_0 + kr$, и период $r$ останется неизвестным. Здесь вступает в дело QFT.

4.2. Применение Квантового преобразования Фурье (QFT)

QFT — это операция, применяющая дискретное преобразование Фурье к амплитудам квантового состояния. Действие QFT на состояние $|x\rangle$ определяется следующим образом:

$$ \text{QFT} |x\rangle = \frac{1}{\sqrt{Q}} \sum_{y=0}^{Q-1} e^{2\pi i \frac{xy}{Q}} |y\rangle $$

Когда это применяется к $|\psi_3\rangle$, возникает фазовая интерференция (квантовая интерференция).

$$ |\psi_4\rangle = \text{QFT} |\psi_3\rangle = \frac{1}{\sqrt{MQ}} \sum_{y=0}^{Q-1} \sum_{k=0}^{M-1} e^{2\pi i \frac{(x_0 + kr)y}{Q}} |y\rangle $$

Если мы раскроем сумму в этой формуле, появится следующая часть:

$$ \sum_{k=0}^{M-1} e^{2\pi i \frac{kry}{Q}} $$

Сумма этой геометрической прогрессии взаимно усиливается (Конструктивная интерференция, Constructive Interference) только когда $ry/Q$ близко к целому числу, и взаимно уничтожается (Деструктивная интерференция, Destructive Interference) в других случаях.

Следовательно, состояние $|y\rangle$, измеряемое с высокой вероятностью, будет целым числом $y$, удовлетворяющим условию:

$$ \frac{y}{Q} \approx \frac{c}{r} $$

(где $c$ — некоторое целое число).

4.3. Определение периода через разложение в цепную дробь

После получения $y$ в результате измерения используйте классический компьютер для выполнения “разложения в цепную дробь” (Continued Fraction Expansion) $y/Q$. Это позволяет вычислить подходящую дробь $c/r$ для $y/Q$ и с высокой эффективностью извлечь кандидата на период $r$ из знаменателя.

5. Сравнение концептуальных моделей и смена парадигмы

Чтобы интуитивно понять разницу между GNFS и Алгоритмом Шора, приводится концептуальная схема с использованием нотации Mermaid.

Концептуальная схема Алгоритма Шора с использованием квантовой схемы

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


graph TD
 A[Начальное состояние: 0...0] --> B[Суперпозиция всех состояний через преобразование Адамара]
 B --> C[Операция модульного возведения в степень a^x mod N]
 C -->|Квантовая запутанность| D[Коллапс в состояние с периодичностью]
 D --> E[Квантовое преобразование Фурье QFT]
 E -->|Усиление вероятности через интерференцию| F[Измерение: Получение y]
 F --> G[Классическая обработка: Цепная дробь]
 G --> H[Обнаружение периода r]
 H --> I[Вычисление простых множителей N]

 style A fill:#f9f,stroke:#333,stroke-width:2px
 style E fill:#bbf,stroke:#333,stroke-width:2px
 style I fill:#bfb,stroke:#333,stroke-width:2px

Суть смены парадигмы

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

С другой стороны, алгоритм Шора использует “волновую природу квантовой интерференции” . Он оценивает все пути вычислений в состоянии суперпозиции одновременно, подавляет (ослабляет) ненужные ответы с помощью QFT и усиливает только амплитуду вероятности для правильного периода. При этом подход заключается не в поиске в пространстве, а в переходе в совершенно другое измерение: “позволить правильному ответу проявиться самому” .

6. Заключение

В этой статье мы глубоко сравнили математическую основу и структуру алгоритмов между “GNFS” , который является пределом классических вычислений, и “Алгоритмом Шора” , который демонстрирует мощь квантовых вычислений.

В то время как GNFS использует математические ухищрения, такие как выбор многочленов и вычисления с огромными матрицами, чтобы снизить сложность до субэкспоненциального времени, Алгоритм Шора достигает прямого прорыва до полиномиального времени, объединяя базовые принципы квантовой механики (суперпозицию и интерференцию) с математическим инструментом (QFT).

В настоящее время не существует отказоустойчивого квантового компьютера (FTQC) практического масштаба (тысячи кубитов), способного запустить Алгоритм Шора. Однако именно наличие этой теоретической и математической смены парадигмы является главной причиной ускорения глобального перехода к постквантовой криптографии (PQC: Post-Quantum Cryptography) во всем мире уже сегодня.

"Полная анатомия" понимания сильнейшего алгоритма криптоанализа "GNFS" путем его реализации на C++

Sat, 05 Sep 2026 13:04:59 +0900

“Полная анатомия” понимания сильнейшего алгоритма криптоанализа “GNFS” путем его реализации на C++

«Шифрование RSA» фундаментально поддерживает современный Интернет. Его надежность опирается на математическое убеждение, что «факторизация огромного составного числа практически невозможна для современных компьютеров».

Однако человечество никогда не сдается. В настоящее время существует ** самый сильный и передовой алгоритм ** человечества для гигантской факторизации на классических компьютерах (обычных, а не квантовых). Он называется ** “Общий метод решета числового поля” (GNFS: General Number Field Sieve) **.

В этой статье мы полностью публикуем код реализации на C++ (с использованием целых чисел произвольной точности boost::multiprecision библиотеки Boost), который строго моделирует эту передовую логику вычислений GNFS, и подробно объясняем стоящую за ней «алгебраическую теорию чисел».

Пожалуйста, насладитесь тайнами математики и мощью информатики, которая их покоряет, вместе с исходным кодом.

1. Логический фреймворк GNFS (полный исходный код)

Сначала представим всю картину реализации GNFS на C++, которая будет здесь объясняться. Фактический метод решета числового поля (например, CADO-NFS) — это гигантская распределенная система из сотен тысяч строк кода. Однако этот код извлекает ** «5 основных конвейеров (фаз)» **, составляющих GNFS, проектирует их как классы и строго моделирует в минимальной конфигурации без потери математического смысла.

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227


#include <iostream>
#include <vector>
#include <cmath>
#include <map>
#include <set>
#include <chrono>
#include <boost/multiprecision/cpp_int.hpp>

// Использование чисел произвольной точности Boost.Multiprecision
using namespace boost::multiprecision;

// ============================================================================
// [SOTA GNFS] General Number Field Sieve Передовой логический фреймворк
//
// Этот код строго моделирует 5 конвейеров современного GNFS,
// используемого в CADO-NFS и др., как классы на C++ (Boost).
// ============================================================================

struct Relation {
 int64_t a;
 int64_t b;
 std::vector<uint32_t> rational_primes;
 std::vector<uint32_t> algebraic_primes;
};

// ============================================================================
// Фаза 1: Выбор полинома (алгоритм КлейнЮнга)
// ============================================================================
class PolynomialSelector {
public:
 int degree;
 std::vector<cpp_int> f; // Алгебраический полином f(x)
 std::vector<cpp_int> g; // Рациональный полином g(x) = x - m
 cpp_int m;

 PolynomialSelector(int d) : degree(d) {}

 // Генерация начального полинома на основе m-расширения (в реальности используется более сложное сокращение базиса решетки LLL)
 void select(const cpp_int& N) {
 std::cout << "[Фаза 1] Выбор полинома (Степень " << degree << ") начинается..." << std::endl;
 // Простое m-расширение (степени d)
 // m = N^(1/d)
 cpp_int N_copy = N;
 m = 1;
 // Простая аппроксимация m (без использования функций Boost)
 cpp_int low = 1, high = N;
 while (low <= high) {
 cpp_int mid = low + (high - low) / 2;
 cpp_int p = 1;
 for(int i=0; i<degree; ++i) p *= mid;
 if (p <= N) { m = mid; low = mid + 1; }
 else { high = mid - 1; }
 }

 f.resize(degree + 1);
 cpp_int temp = N;
 for (int i = 0; i <= degree; ++i) {
 f[i] = temp % m;
 temp /= m;
 }

 g = {-m, 1}; // g(x) = x - m

 std::cout << " -> m = " << m << std::endl;
 std::cout << " -> f(x) = ";
 for(int i = degree; i >= 0; --i) {
 std::cout << f[i] << "x^" << i << (i > 0 ? " + " : "");
 }
 std::cout << "\n[Фаза 1] Завершено." << std::endl;
 }
};

// ============================================================================
// Фаза 2: Решето на решетках (Lattice Sieving)
// ============================================================================
// В современных GNFS вместо Line Sieve используется Special-q Lattice Sieving,
// разработанное Франке и КлейнЮнгом, которое стало де-факто стандартом.
class LatticeSieve {
 uint32_t rational_bound;
 uint32_t algebraic_bound;
 std::vector<uint32_t> rational_fb;
 std::vector<uint32_t> algebraic_fb;

public:
 LatticeSieve(uint32_t rb, uint32_t ab) : rational_bound(rb), algebraic_bound(ab) {}

 void generate_factor_bases() {
 std::cout << "[Фаза 2] Генерация факторных баз (Рациональная граница: " << rational_bound << ", Алгебраическая граница: " << algebraic_bound << ")" << std::endl;
 // (Опущено) На самом деле выполняется генерация простых чисел и фильтрация с помощью символов Лежандра и т.д.
 }

 std::vector<Relation> sieve(const PolynomialSelector& poly) {
 std::cout << "[Фаза 2] Special-q Lattice Sieving активен..." << std::endl;
 std::vector<Relation> relations;
 // Макетная реализация: реальное решето на решетках сканирует сотни ГБ памяти блоками.
 // Пары (a, b) проецируются на решетку (a = i*q + j*...) для каждого особого простого q,
 // и выполняется просеивание с экстремальной эффективностью кэширования.

 // Добавлено фиктивное отношение для демонстрации
 Relation r; r.a = 17; r.b = 3;
 r.rational_primes = {2, 5};
 r.algebraic_primes = {3, 7};
 relations.push_back(r);

 std::cout << "[Фаза 2] Найдено " << relations.size() << " отношений." << std::endl;
 return relations;
 }
};

// ============================================================================
// Фаза 3: Фильтрация (удаление синглтонов и слияние клик)
// ============================================================================
class Filter {
public:
 void reduce_matrix(std::vector<Relation>& relations) {
 std::cout << "[Фаза 3] Фильтрация отношений..." << std::endl;
 // 1. Удаление синглтонов (удаление отношений с простыми числами, появляющимися только раз)
 // 2. Слияние клик (объединение отношений для превращения разреженной матрицы в плотную)
 // В реальности алгоритмы вроде Union-Find сжимают матрицу из сотен миллионов строк до нескольких миллионов.
 std::cout << "[Фаза 3] Размер матрицы оптимально уменьшен." << std::endl;
 }
};

// ============================================================================
// Фаза 4: Линейная алгебра над GF(2) (метод Блока Видемана)
// ============================================================================
class LinearAlgebraGF2 {
public:
 // В современных суперкомпьютерных средах вместо метода Block Lanczos
 // передовым является метод Block Wiedemann (реализация Coppersmith), удобный для распределенных вычислений.
 std::vector<std::vector<int>> solve_nullspace(const std::vector<Relation>& relations) {
 std::cout << "[Фаза 4] Алгоритм Блока Видемана над GF(2) начинается..." << std::endl;
 // Итеративное вычисление произведения разреженной матрицы и вектора,
 // поиск нескольких векторов решений (ядер), где M * x = 0 mod 2.

 std::vector<std::vector<int>> dependencies; // Список зависимостей
 // Фиктивные данные
 dependencies.push_back({0});

 std::cout << "[Фаза 4] Найдено " << dependencies.size() << " линейных зависимостей (полных квадратов)." << std::endl;
 return dependencies;
 }
};

// ============================================================================
// Фаза 5: Алгебраический квадратный корень (Algebraic Square Root)
// ============================================================================
class AlgebraicSquareRoot {
public:
 void compute_and_factor(const std::vector<Relation>& relations, const std::vector<int>& dep, const cpp_int& N) {
 std::cout << "[Фаза 5] Вычисление алгебраического квадратного корня..." << std::endl;

 // 1. Вычисление рационального корня V
 cpp_int V = 1;
 // V = sqrt( prod(a - bm) ) mod N

 // 2. Вычисление алгебраического корня gamma (методом Монтгомери и др.)
 // Нахождение элемент gamma в огромном алгебраическом поле O_K и его отображение в реальный мир гомоморфизмом phi
 // Y = phi(gamma) mod N
 cpp_int Y = 1;

 // Предполагается, что в Фазах 2 и 4 были добавлены столбцы квадратичных характеров (Quadratic Characters)
 // во избежание препятствий группы классов идеалов и группы единиц.

 std::cout << " -> Гомоморфизм phi применен." << std::endl;
 std::cout << "[Фаза 5] Вычисление НОД(V - Y, N)..." << std::endl;

 cpp_int factor = gcd(V - Y, N); // НОД(X-Y, N)

 if (factor > 1 && factor < N) {
 std::cout << "\n================================================================" << std::endl;
 std::cout << "[УСПЕХ] Найден нетривиальный множитель: " << factor << std::endl;
 std::cout << " Другой множитель: " << N / factor << std::endl;
 std::cout << "================================================================" << std::endl;
 } else {
 std::cout << "[НЕУДАЧА] Тривиальное решение. Пробуем следующую зависимость..." << std::endl;
 }
 }
};

// ============================================================================
// Основной конвейер выполнения
// ============================================================================
int main() {
 std::cout << "================================================================" << std::endl;
 std::cout << " [SOTA GNFS] Движок General Number Field Sieve (Boost C++) " << std::endl;
 std::cout << "================================================================" << std::endl;

 // Гигантское составное число N (например, RSA-270)
 cpp_int N("233108530344407544527637656910680524145619812480305449042948611968495918245135782867888369318577116418213919268572658314913060672626911354027609793166341626693946596196427744273886601876896313468704059066746903123910748277606548649151920812699309766587514735456594993207");

 // Степень полинома (для > 130 цифр обычно выбирают 5-6)
 int degree = 6;

 // Инициализация конвейера
 PolynomialSelector poly_select(degree);
 LatticeSieve sieve(10000000, 20000000); // Реальные границы составляют миллионы
 Filter filter;
 LinearAlgebraGF2 linalg;
 AlgebraicSquareRoot sqrt_step;

 auto start_time = std::chrono::high_resolution_clock::now();

 // 1. Выбор полинома
 poly_select.select(N);

 // 2. Просеивание (sieve)
 sieve.generate_factor_bases();
 std::vector<Relation> relations = sieve.sieve(poly_select);

 // 3. Фильтрация (сжатие матрицы)
 filter.reduce_matrix(relations);

 // 4. Линейная алгебра (Поиск нуль-пространства над GF(2))
 std::vector<std::vector<int>> dependencies = linalg.solve_nullspace(relations);

 // 5. Вычисление алгебраического квадратного корня и НОД
 for (const auto& dep : dependencies) {
 sqrt_step.compute_and_factor(relations, dep, N);
 }

 auto end_time = std::chrono::high_resolution_clock::now();
 std::chrono::duration<double> elapsed = end_time - start_time;
 std::cout << "\n[Система] Конвейер SOTA GNFS завершен за " << elapsed.count() << " секунд." << std::endl;

 return 0;
}

Итак, как этот код разрушает криптографические стены? Давайте разберем тщательный алгоритм и высшую математику каждой из 5 фаз.

2. Конечная цель GNFS: $X^2 \equiv Y^2 \pmod N$

Как и в случае GNFS, большинство современных алгоритмов факторизации гигантских чисел стремятся найти нетривиальную пару $(X, Y)$, удовлетворяющую следующему сравнению:

$$X^2 \equiv Y^2 \pmod N$$

Это означает, что «остаток от деления $X^2$ и $Y^2$ на $N$ одинаков». Преобразовав это, получим: $X^2 - Y^2 \equiv 0 \pmod N$ Другими словами, $(X-Y)(X+Y)$ кратно $N$.

Если $X \not\equiv \pm Y \pmod N$ (нетривиальное решение), это означает, что между $(X-Y)$ и $N$ есть «общий делитель больше 1 и меньше $N$». Если мы воспользуемся алгоритмом Евклида для вычисления ** $\gcd(X-Y, N)$ **, то легко найдем простой множитель $N$.

Однако поиск этих $X$ и $Y$ сродни поиску иголки в пустыне. Поэтому GNFS применяет гениальный подход: создает ** два мира ** — «мир реальных целых чисел» и «мир алгебраических числовых полей полиномов» — для распределения вычислений.

3. Фаза 1: Выбор полинома (Polynomial Selection)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


class PolynomialSelector {
 // ...
 void select(const cpp_int& N) {
 // вычисление m = N^(1/d) и m-расширение
 // ...
 for (int i = 0; i <= degree; ++i) {
 f[i] = temp % m;
 temp /= m;
 }
 g = {-m, 1}; // g(x) = x - m
 }
};

Первый шаг GNFS — создание «магического полинома», связывающего оба мира. Для гигантского числа $N$ выбираем целое $m$. Обычно так, чтобы $m \approx N^{1/d}$ (в коде предполагается полином степени $d=6$).

Затем мы разлагаем $N$ по основанию $m$ и используем его коэффициенты для построения полинома $f(x)$:

$$N = c_d m^d + c_{d-1} m^{d-1} + \dots + c_1 m + c_0$$ $$f(x) = c_d x^d + c_{d-1} x^{d-1} + \dots + c_1 x + c_0$$

Этот полином $f(x)$ обладает крайне важным свойством: ** «если подставить $m$ в переменную $x$, получится ровно $N$ ($f(m) = N$)» **. То есть $f(m) \equiv 0 \pmod N$. Рациональный полином определяется как $g(x) = x - m$.

В результате ** «мир алгебраического поля $\mathbb{Z}[\alpha]$» **, управляемый корнем $\alpha$ из $f(x)=0$, и обычный ** «мир рациональных чисел (целых) $\mathbb{Z}$» ** прочно связываются «гомоморфизмом колец» $x \to m$.

В современных CADO-NFS и других реализациях используются алгоритмы КлейнЮнга и алгоритм LLL-редукции базиса решетки для поиска «самого удобного полинома $f(x)$», при котором коэффициенты не становятся чрезмерно большими, а простые числа легче появляются на следующих этапах. Этот поиск может занимать месяцы.

4. Фаза 2: Решето на специальной q-решетке (Special-q Lattice Sieving)

1
2
3
4
5
6
7
8
9


class LatticeSieve {
 // ...
 std::vector<Relation> sieve(const PolynomialSelector& poly) {
 // ...
 // Пары (a, b) проецируются на решетку для каждого особого простого q,
 // и выполняется просеивание, максимизирующее эффективность кэширования.
 // ...
 }
};

Подготовив оба мира, мы переходим к поиску «гладких чисел (состоящих только из маленьких простых множителей)» в обоих мирах. Генерируются бесчисленные пары целых чисел $(a, b)$ и вычисляются два значения:

Рациональное значение : $a - bm$
Алгебраическая норма : $b^d f(a/b)$

Цель GNFS состоит в том, чтобы собрать от десятков до сотен миллионов ** «пар (отношений), в которых и рациональное, и алгебраическое значения могут быть полностью факторизованы только малыми простыми множителями» **.

В раннем GNFS использовалось «Линейное решето (Line Sieve)», где $(a, b)$ располагались на плоскости $xy$ и делились на простые числа. Но это было крайне медленно из-за промахов кэша при частом обращении к памяти.

Поэтому современные коды используют метод, называемый ** “Special-q Lattice Sieve” **. Фиксируется достаточно большое простое число $q$, и вычисляются только пары $(a, b)$, где «алгебраическое значение гарантированно делится на $q$». Пары, удовлетворяющие этому условию, образуют «решетку (Lattice)» на плоскости, делая скачки адресов в памяти постоянными, что идеально вписывается в кэш L1/L2 процессора. Введение решета на решетках резко повысило скорость вычислений GNFS.

5. Фаза 3: Фильтрация (Filtering)

1
2
3
4
5
6
7


class Filter {
public:
 void reduce_matrix(std::vector<Relation>& relations) {
 // 1. Удаление синглтонов (удаление отношений с простыми числами, появляющимися только 1 раз)
 // 2. Слияние клик (объединение отношений для уплотнения разреженной матрицы)
 }
};

Сотни миллионов отношений, собранных компьютерами по всему миру за несколько месяцев на Фазе 2. Однако, если их сразу передать на следующий этап «вычисления матрицы», память суперкомпьютера переполнится.

Следовательно, происходит экстремальный процесс сжатия матрицы, называемый ** Фильтрацией (Filtering) **.

Удаление синглтонов (Singleton removal) Предположим, гигантское простое число $p$ встречается только «1 раз» во всех миллионах отношений. Наша цель — «сделать показатели всех простых чисел четными (кратными 2)», так что простое число, появляющееся лишь однажды, не может стать четным. Поэтому отношения, содержащие такое простое число, немедленно удаляются как «бесполезный мусор». Это вызывает цепную реакцию, убирая миллионы строк данных.
Слияние клик (Clique merging) Далее, путем сложения отношений, разделяющих определенные простые числа, разреженная матрица сжимается и становится более плотной (используя метод, подобный поиску клик в теории графов).

Благодаря этой оптимизации, гигантская разреженная матрица радикально сжимается до вычислимых размеров.

6. Фаза 4: Линейная алгебра над GF(2) (метод Блока Видемана)

1
2
3
4
5
6
7


class LinearAlgebraGF2 {
public:
 std::vector<std::vector<int>> solve_nullspace(const std::vector<Relation>& relations) {
 // Итеративное вычисление произведения разреженной матрицы и вектора,
 // поиск решений (ядер), где M * x = 0 mod 2.
 }
};

Теперь мы подходим к сути головоломки. Мы объединяем собранные отношения для поиска ** «комбинаций, в которых степени всех простых множителей становятся четными» **.

Математически, используя гигантскую матрицу $M$, элементы которой представляют собой «четность или нечетность (т.е. 0 или 1)» степени каждого простого числа, и вектор $x$, показывающий, какие отношения используются, мы решаем уравнение (поиск нуль-пространства): $M \cdot x \equiv 0 \pmod 2$

Нам нужно решить систему уравнений матрицы размером миллионы на миллионы строк и столбцов. При обычном методе Гаусса сложность составляет $O(N^3)$, и вычисления не закончатся до конца Вселенной.

Поэтому современные реализации применяют ** «Метод Блока Видемана (Block Wiedemann)» **. Это вид метода подпространства Крылова, который находит решение путем итеративного умножения матрицы на вектор, эксплуатируя то, что матрица $M$ «очень разреженная (почти все 0)». В отличие от старого метода Block Lanczos, метод Block Wiedemann полностью разделяет вычислительный процесс на кластеры, демонстрируя огромную мощь в современных распределенных облачных вычислениях и на суперкомпьютерах.

7. Фаза 5: Алгебраический квадратный корень (Algebraic Square Root) и крушение криптографии

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


class AlgebraicSquareRoot {
public:
 void compute_and_factor(...) {
 // 1. Вычисление рационального квадратного корня V
 cpp_int V = 1;

 // 2. Вычисление алгебраического корня gamma
 cpp_int Y = 1;

 // ...
 cpp_int factor = gcd(V - Y, N); // GCD(X-Y, N)
 }
};

Через вычисления матрицы на Фазе 4 мы получили набор отношений $S$, которые «при перемножении дают четные степени для всех простых множителей». Это позволяет нам создать «квадрат» в обоих мирах — рациональном и алгебраическом.

Поскольку рациональная сторона — это просто умножение целых чисел, вычислить квадратный корень $V$ легко.

$$V^2 = \prod_{S} (a - bm)$$

Но настоящий ад ждет на «алгебраической стороне». В мире алгебраических полей $\mathbb{Z}[\alpha]$ уникальность факторизации на простые не сохраняется, поэтому мы вычисляли, используя идеалы. Расчеты матрицы гарантировали лишь ** «создание квадрата идеала», но не «гарантировали, что это квадрат элемента ($\gamma^2$)» **.

Здесь возникают грозные барьеры алгебраической теории чисел — «препятствие группы классов идеалов» и «препятствие группы единиц». Чтобы преодолеть эту стену, GNFS использует магию ** «Квадратичных характеров (Quadratic Characters)» **. В матрицу Фазы 4 заранее добавляются несколько десятков специальных столбцов квадратичных вычетов (символов Лежандра) для особых простых идеалов. В результате найденный набор $S$ с ошеломляющей вероятностью обходит все препятствия и благополучно формирует «истинный квадрат элемента $\gamma^2$».

Процесс нахождения $\gamma$ (Алгебраический квадратный корень) выполняется с помощью невероятно сложного алгоритма, такого как метод Монтгомери.

И, наконец, алгебраический корень $\gamma$ переносится в реальный мир с помощью гомоморфизма колец $\phi$ (подстановка $m$ вместо $x$), образуя $Y$. Установив $V$ с рациональной стороны как $X$, мы получаем абсолютное уравнение, к которому стремились:

$$X^2 \equiv Y^2 \pmod N$$

Остается только вычислить $\gcd(X-Y, N)$. За долю секунды 0,001 с нетривиальный множитель выводится на экран, и гордая, неприступная криптография RSA полностью рушится.

Заключение

GNFS — это не просто метод программирования. Это шедевр человеческого интеллекта, который покорил «глубины чистой математики», такие как абстрактная алгебра, теория колец и группы классов идеалов, с помощью «экстремальной инженерии» — распределенной архитектуры суперкомпьютеров и кэш-оптимизации.

Наши повседневные сообщения в чатах или данные кредитных карт защищены именно этими колоссальными математическими битвами.

Мы надеемся, что этот фреймворк на C++ позволил вам почувствовать «романтику математики и компьютеров», стоящую за передовыми алгоритмами криптоанализа.

Истинная математическая структура общего метода решета числового поля (GNFS)

Sat, 05 Sep 2026 02:26:13 +0900

Истинная математическая структура общего метода решета числового поля (GNFS)

Конечная цель GNFS — найти $X, Y$ такие, что $X^2 \equiv Y^2 \pmod N$. Для достижения этого математики построили мост между “миром реальных целых чисел” и “миром алгебраических полей”. Этим мостом является «гомоморфизм».

Этап 1: «Гомоморфизм» (Homomorphism), соединяющий миры

1. Выбор многочлена и определение корня

Для гигантского составного числа $N$ мы выбираем некоторое целое число $m$ и многочлен $f(x)$ так, чтобы $f(m) \equiv 0 \pmod N$. (Пример: Разложите $N$ по основанию $m$ и постройте $f(x)$ из его коэффициентов. При этом предполагается, что $f(x)$ неприводим над полем рациональных чисел $\mathbb{Q}$).

Далее, пусть $\alpha$ — один из «комплексных корней» уравнения $f(x) = 0$. Естественно, $f(\alpha) = 0$. $\alpha$ — это не целое число, а сложное число (алгебраическое число), которое может содержать корни или мнимые единицы.

2. Построение кольца (Ring) и гомоморфизма

Здесь мы подготавливаем два математических «кольца» (миры, где определены сложение и умножение):

Мир A: $\mathbb{Z}[\alpha]$ (Кольцо алгебраических целых чисел, содержащее $\alpha$) Это мир чисел, выраженных в виде $a + b\alpha + c\alpha^2 + \dots$.
Мир B: $\mathbb{Z}/N\mathbb{Z}$ (Кольцо вычетов по модулю $N$) Мир сравнений (по модулю), состоящий только из целых чисел от $0$ до $N-1$.

Здесь мы определяем отображение (mapping) $\phi$ из Мира A в Мир B следующим образом: $$\phi : \mathbb{Z}[\alpha] \to \mathbb{Z}/N\mathbb{Z}$$ $$\phi(\alpha) = m \pmod N$$

Это отображение $\phi$ — магическая операция, которая полностью заменяет переменную $\alpha$ в Мире A на целое число $m$ в Мире B. Это $\phi$ обладает чрезвычайно мощным свойством, называемым “Гомоморфизм колец” (Ring Homomorphism). Гомоморфизм — это свойство “перехода в другой мир без разрушения структуры сложения и умножения”. То есть выполняются следующие уравнения:

$\phi(X \times Y) = \phi(X) \times \phi(Y)$
$\phi(X^2) = \phi(X)^2$

Что все это значит? Если мы сможем создать “полный квадрат” ($\gamma^2$) из сложного элемента $\gamma$ в “Мире A” (мире $\alpha$), мы сможем прыгнуть в “Мир B” (мир остатков) с помощью $\phi$, и форма квадрата $\phi(\gamma)^2$ будет идеально сохранена.

Этап 2: Крах разложения на простые множители и рождение «Идеала» (Ideal)

Мы хотим собрать множество подходящих элементов $(a - b\alpha)$ в Мире A ($\mathbb{Z}[\alpha]$) и перемножить их, чтобы получить «полный квадрат» (квадратичный элемент). Обычно мы могли бы разложить собранные $(a - b\alpha)$ на «простые множители» и объединить их так, чтобы все показатели степеней простых чисел стали четными (решается с помощью матриц), создавая таким образом квадрат.

Однако здесь на пути встает стена алгебраического отчаяния. В мире алгебраических полей, таких как $\mathbb{Z}[\alpha]$, “уникальность разложения на простые множители (каждое число может быть представлено как произведение простых чисел только одним способом)”, которую мы изучали в средней школе, полностью рушится.

(Пример: В некоторых мирах алгебраических полей $6 = 2 \times 3$, и в то же время $6 = (1+\sqrt{-5}) \times (1-\sqrt{-5})$, что делает невозможным узнать, какие из них являются истинными простыми числами).

Если разложение на простые множители не уникально, то головоломка “подсчета простых чисел до тех пор, пока их не станет четное количество” (метод решета) принципиально невыполнима.

Спасение Куммера и Дедекинда: «Идеал»

Этот крах был спасен концепцией “Идеала” (Ideal: Идеальное число), созданной математиками 19 века. Вместо того чтобы рассматривать сам элемент, рассматривая “множество кратных (идеал)”, порожденное этим элементом, разложение на простые множители снова стало возможным.

В кольце целых чисел алгебраического поля $\mathcal{O}_K$ (более совершенном кольце, включающем $\mathbb{Z}[\alpha]$), даже если элементы не могут быть однозначно разложены на множители, доказано, что “Идеал всегда может быть однозначно разложен на простые множители как произведение ‘простых идеалов’ ($\mathfrak{p}$)”.

Поэтому в GNFS вместо разложения самого элемента $(a - b\alpha)$ мы выполняем разложение на простые идеалы главного идеала $\langle a - b\alpha \rangle$, который он порождает.

Этап 3: Норма (Norm) и два решета (Sieve)

Тогда как нам узнать, на какие простые идеалы распадается идеал $\langle a - b\alpha \rangle$? Здесь мы используем функцию, называемую “Норма” (Norm). Норма — это функция, которая преобразует сложные элементы алгебраического поля в “обычные целые числа $\mathbb{Z}$” реального мира.

Норма элемента $(a - b\alpha)$ вычисляется с помощью простого многочлена $b^d f(a/b)$ (где $d$ — степень $f(x)$).

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

Поэтому GNFS одновременно вычисляет следующие две вещи для огромного количества пар целых чисел $(a, b)$ и собирает только те пары, где обе являются “гладкими числами”:

Рациональное решето (Rational Sieve): $a - bm$ (значение в реальном мире)
Алгебраическое решето (Algebraic Sieve): $b^d f(a/b)$ (норма в мире алгебраического поля)

Мы собираем десятки миллионов пар $(a, b)$, обе из которых гладкие, решаем данные о разложении идеалов на простые множители (сколько простых идеалов присутствует) в виде гигантской матрицы (линейная алгебра над GF(2)) и находим множество $S$ пар таких, что “при перемножении показатели всех простых идеалов становятся четными”.

Этап 4: Два «Препятствия» и группа классов идеалов

С помощью матричных вычислений мы обнаружили, что умножение всех идеалов $(a - b\alpha)$ во множестве $S$ дает квадрат некоторого идеала $I$.

$$\prod_{S} \langle a - b\alpha \rangle = I^2$$

Но это еще не конец. Самая глубокая и трудная математическая стена в GNFS находится здесь.

В конечном итоге нам нужен не “квадрат идеала”, а “квадрат элемента” ($\gamma^2$) для подстановки в отображение $\phi$. Только потому, что идеал возведен в квадрат, не означает, что сам элемент возведен в квадрат. Здесь существуют два невероятно сильных математических препятствия (Obstructions).

Препятствие 1: Стена группы классов идеалов (Ideal Class Group)

Идеал $I$ не всегда является “идеалом, порожденным одним элементом (главным идеалом)”. Невозможно извлечь конкретный элемент $\gamma$ из идеала, который не является главным.

Здесь появляется концепция “Группы классов идеалов (Class Group, $Cl_K$)”. Группа классов идеалов — это группа, которая измеряет, “сколько неглавных идеалов существует в мире алгебраического поля (насколько разрушена уникальность разложения на простые множители)”. Даже если $\prod \langle a - b\alpha \rangle$ становится $I^2$, если $I$ не является единичным элементом (главным идеалом) в группе классов идеалов, мы не можем вернуть его к квадрату элемента.

Препятствие 2: Стена группы единиц (Unit Group)

Допустим, нам повезло, и $I$ является главным идеалом $\langle \gamma \rangle$. Тогда $\prod \langle a - b\alpha \rangle = \langle \gamma^2 \rangle$. Вы можете подумать: “Отлично, элемент тоже в квадрате!”, но вы глубоко ошибаетесь.

Тот факт, что идеалы (множества кратных) равны, не означает, что элементы полностью равны. Всегда будет сдвиг на “Единицу” (Unit: число, обратное которому также является целым, например 1 или -1). Другими словами, фактическое равенство элементов выглядит следующим образом:

$$\prod_{S} (a - b\alpha) = u \cdot \gamma^2$$

(где $u$ — элемент группы единиц $U_K$)

Если только эта единица $u$ сама не является квадратом чего-либо (квадратичным элементом), левая часть никогда не сможет стать “идеальным квадратом элемента”.

Этап 5: Магия Адлемана «Квадратичные характеры» (Quadratic Characters)

Препятствие группы классов идеалов и препятствие группы единиц. Как нам их преодолеть? Здесь появляется гениальный метод, называемый “Квадратичными характерами” (Quadratic Characters), введенный криптографом Леонардом Адлеманом (буква “A” в RSA) и его коллегами.

Чтобы определить, “является ли элемент полным квадратом в алгебраическом поле”, мы используем версию символа Лежандра (квадратичного вычета) для алгебраических полей. В гигантскую матрицу (головоломку для того, чтобы сделать количество простых идеалов четным) мы тайно добавляем несколько десятков дополнительных условий (столбцов), утверждающих, что “квадратичные характеры для некоторых особых простых идеалов $\mathfrak{q}$ также все становятся равными $1$ (четными)”.

Когда мы находим множество $S$, удовлетворяющее этим дополнительным условиям с помощью матричных вычислений, глубокая теорема алгебраической теории чисел гарантирует, что “как препятствие группы классов идеалов, так и препятствие группы единиц исчезнут естественным образом с подавляющей вероятностью”.

Благодаря этому мы наконец получаем истинное уравнение:

$$\prod_{S} (a - b\alpha) = \gamma^2$$

Финальный этап: Слияние миров и взлом криптографии

Наконец, все кусочки головоломки на месте.

[Элемент в мире алгебраического поля (Мир A)] $\gamma^2 = \prod (a - b\alpha)$ (Используйте алгоритм извлечения квадратного корня, чтобы найти $\gamma$)

[Элемент в реальном мире (мир рациональных чисел)] $V^2 = \prod (a - bm)$ (Это просто обычное умножение целых чисел, поэтому квадратный корень $V$ можно найти легко)

Теперь настало время для работы первого магического моста, который мы создали, гомоморфизма $\phi$. Мы переносим элемент $\gamma$ из Мира A в Мир B (мир остатков $N$) с помощью $\phi$ (отображения, которое подставляет $m$ вместо $\alpha$).

$$Y = \phi(\gamma) \pmod N$$

С другой стороны, мы берем $V$, созданный в реальном мире, прямо в мир остатков и называем его $X$.

$$X = V \pmod N$$

Благодаря свойству гомоморфизма “сохранять структуру”, квадратичное отношение, которое было истинным в Мире A, идеально сохраняется в Мире B (мире по модулю $N$). Более того, поскольку исходные пары $(a, b)$ были сформированы так, чтобы соответствовать как $a - b\alpha$ и $a - bm$, эти $X$ и $Y$ сталкиваются в мире по модулю $N$ и порождают следующее абсолютное уравнение:

$$X^2 \equiv Y^2 \pmod N$$

Теперь остается только молиться, чтобы $X$ и $Y$ не были тривиальными решениями ($X \equiv \pm Y$), а затем мы вычисляем: $\gcd(X - Y, N)$

Если это нетривиальное решение, алгоритм Евклида пронесется за 0,001 секунды, и секретные простые числа $p$ и $q$, которые являются сердцем криптографии RSA, будут выведены на экран.

Это и есть полная картина “Общего метода решета числового поля (GNFS)”, который объединяет в себе суть современной математики.

Что такое Общий метод решета числового поля (GNFS) — сильнейшая математика человечества, взламывающая криптографию интернета?

Sat, 05 Sep 2026 02:09:08 +0900

Что такое Общий метод решета числового поля (GNFS) — сильнейшая математика человечества, взламывающая криптографию интернета?

Интернет, которым мы пользуемся каждый день. Все наши коммуникации, будь то сообщения в LINE, видео на YouTube или покупки на Amazon, защищены «криптографией». В настоящее время самым распространенным алгоритмом шифрования в мире является «шифр RSA».

Суть защиты RSA очень проста. Она использует математическое свойство, заключающееся в том, что «даже компьютеры не могут решить задачу факторизации гигантских чисел на простые множители» . Например, для числа «15» сразу понятно, что это «3 × 5». Но как только число становится «270-значным», даже если объединить все суперкомпьютеры мира, на его решение уйдут сотни миллионов лет.

Однако математики тоже не сидят сложа руки. Чтобы взломать этот неприступный шифр, человечество создало магический алгоритм (вычислительную процедуру) под названием «Общий метод решета числового поля (GNFS — General Number Field Sieve)» .

В этой статье мы не будем использовать сложные технические термины, а опираясь только на знания математики средней школы (разложение на простые множители, алгебраические выражения, наибольший общий делитель) , полностью шаг за шагом объясним, как этот «сильнейший алгоритм человечества» взламывает шифры!

Глава 1: Цель взлома — «формула из средней школы»

Главный прием против факторизации гигантских чисел. Это формула, которую изучают в средних классах.

$X^2 - Y^2 = (X + Y)(X - Y)$

Вы можете подумать: «Э-э, неужели такая базовая формула может взломать шифр?». Однако это и есть тот самый главный ключ, который все открывает.

Главная цель при взломе шифра — найти для огромного числа $N$ «такие числа ($X$ и $Y$), что остатки от деления $X^2$ и $Y^2$ на $N$ будут одинаковыми» .

Почему «одинаковые остатки» могут взломать шифр?

Предположим, у двух чисел $X^2$ и $Y^2$ «остатки от деления на $N$ одинаковые». Одинаковые остатки означают, что при вычитании «$X^2 - Y^2$» результат обязательно будет без остатка делиться на $N$ (станет кратным $N$) .

Здесь давайте представим, что огромное число $N$, используемое в шифре, образовано умножением двух секретных простых чисел ($p$ и $q$) ($N = p \times q$).

Если разложить на множители $X^2 - Y^2$, то получится $(X - Y)(X + Y)$ . То, что это число кратно $N$, означает, что где-то в этом умножении спрятаны секретные простые числа $p$ и $q$.

И тут происходит чудо. Математическая вероятность того, что два простых числа $p$ и $q$ разойдутся по разным «комнатам» — «$p$ в комнату $(X - Y)$», а «$q$ в комнату $(X + Y)$» — составляет ровно 50% (одна вторая) .

Предположим, что только простое число $p$ попало в комнату $(X - Y)$. Давайте вычислим «наибольший общий делитель (самый большой общий компонент)» между $(X - Y)$ и $N$.

Содержимое $(X - Y)$ = $p \times$ какое-то число
Содержимое $N$ = $p \times q$ Единственный общий компонент здесь — это «$p$» !

Другими словами, в момент вычисления наибольшего общего делителя скрытое простое число $p$ внезапно выпадает, и шифр оказывается полностью взломанным. (Наибольший общий делитель можно моментально вычислить даже на смартфоне с помощью «Алгоритма Евклида»)

[Мини-колонка: Почему именно квадрат? Разве куб или удвоение не подойдут?]

Если взять «$2X - 2Y$», это превратится в $2(X - Y)$, и останется только одна комната, так что простые числа разделить не получится. Если взять «$X^3 - Y^3$», размеры комнат станут несбалансированными, и вычисления станут неоправданно тяжелыми. Для идеального разделения двух простых чисел «квадрат», образующий две красивые комнаты, является самым оптимальным вариантом.

Глава 2: Как найти X и Y? «Головоломка по сбору карточек с простыми числами»

Цель ясна. Однако, если пытаться искать «$X^2$ и $Y^2$ с одинаковыми остатками» наугад, мы не найдем их до самого конца существования Вселенной. Поэтому математики придумали гениальный метод под названием «Головоломка по сбору карточек с простыми числами» .

Шаг 1: Просеивание только золотого песка (гладких чисел)

Сначала мы берем произвольное число $Z$, возводим его в квадрат и вычисляем остаток $W$ от деления на $N$. (Мир остатков: $Z^2 = W$)

Полученный остаток $W$ мы раскладываем на простые множители. Здесь, только когда получается «$W$, состоящее исключительно из маленьких простых чисел, таких как 2, 3, 5, 7» , мы оставляем эту формулу как «выигрышную карточку». Если примешивается большое простое число — мы ее выбрасываем. Это похоже на работу с ситом (решетом) в реке: мы отбрасываем большие камни и собираем только золотой песок.

Шаг 2: Головоломка с приведением к «четному числу»

Предположим, мы собрали 3 таких карточки с золотым песком:

Карточка A: $Z_1^2 = 2^3 \times 3^1$
Карточка B: $Z_2^2 = 2^1 \times 5^1$
Карточка C: $Z_3^2 = 3^1 \times 5^1$

Давайте перемножим их все. Правая сторона станет $(2^3 \times 3^1) \times (2^1 \times 5^1) \times (3^1 \times 5^1)$, а после упрощения получится «$2^4 \times 3^2 \times 5^2$» .

Поразительно, но количество простых чисел стало «4, 2, 2» — все они стали четными ! То, что все они стали четными, означает, что если поделить их количество пополам, мы получим «квадрат чего-либо». А именно: $(2^2 \times 3^1 \times 5^1)^2 = (60)^2$.

Поскольку левая сторона равна $(Z_1 \times Z_2 \times Z_3)^2$, мы, наконец, получаем: $X = (Z_1 \times Z_2 \times Z_3)$ $Y = 60$ Долгожданная пара «$X^2 = Y^2$» завершена!

Для компьютеров головоломки с подсчетом того, «четное число или нечетное (0 или 1)», даются очень легко, поэтому с помощью этого метода можно очень быстро найти $X$ и $Y$.

Глава 3: Стена отчаяния на пути

Казалось бы, теперь любой шифр можно взломать! …Но тут возникает огромная проблема. Если число шифра $N$ имеет длину до «100 цифр», этот метод (называемый методом квадратичного решета) справляется. Но когда $N$ становится «200-значным или 300-значным», промежуточное значение $W$ становится слишком гигантским.

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

И вот здесь наконец появляется совершенное оружие человечества — «Общий метод решета числового поля (GNFS)» .

Глава 4: Гениальная идея человечества — создание «двух миров»

Гениальность идеи GNFS заключается в следующем: «Раз числа становятся огромными потому, что мы считаем только в реальном мире, давайте создадим “параллельный мир” с помощью полиномов (алгебраических выражений) и разделим вычислительную нагрузку на две части» .

Магия алгебраических выражений

GNFS преобразует огромное число $N$ в алгебраическое выражение, используя базовое число $m$. Например, если $N=100$, мы выбираем $m=4$, тогда $100 = 4^3 + 2(4^2) + 4$. Используя переменную $x$, мы превращаем это в выражение (параллельный мир): $f(x) = x^3 + 2x^2 + x$ .

Самое интересное в этом выражении — его свойство: «Если подставить вместо $x$ число $m$ (в данном примере 4), то можно в любой момент “телепортироваться” обратно к реальному числу $N$» .

Поиск золотого песка одновременно в двух мирах

GNFS генерирует множество произвольных пар целых чисел $(a, b)$ и одновременно выполняет два вычисления:

Реальный мир: $a - b \times m$
Алгебраический мир: значение $a - b \times x$, вычисленное по правилам алгебраических выражений

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

Затем с помощью сита (решета) отсеиваются и собираются только те чудесные пары $(a, b)$, в которых «и в реальном мире, и в алгебраическом мире результаты состоят только из маленьких простых чисел (являются золотым песком)» . Отсюда и происходит название «метод решета числового поля».

Момент взлома шифра

Когда из обоих миров собираются десятки миллионов «карточек с золотым песком», с помощью матричных вычислений на суперкомпьютерах находится «комбинация, при которой количество простых чисел становится полностью четным», точно так же, как во 2-й главе.

Когда комбинация найдена:

Число в квадрате, полученное в реальном мире, обозначается как $X^2$
Выражение в квадрате, полученное в алгебраическом мире, обозначается как $Y(x)^2$

И наконец, мы подставляем $m$ вместо $x$ в $Y(x)$ алгебраического мира, телепортируя его и объединяя с реальным миром. И тут, как по математическому волшебству, строго выполняется условие «остатки $X^2$ и $Y^2$ одинаковы» !

Дальше, как было описано в 1-й главе, достаточно вычислить наибольший общий делитель $X - Y$ и $N$, и неприступный шифр RSA с грохотом рассыпается, открывая секретные простые числа.

Заключение: Математика не заканчивается

Возможно, вы подумали: «Отлично, с помощью GNFS можно взломать любой шифр!». Однако шифр RSA не сдается. В современном интернете используется чудовищно огромное число под названием «RSA-2048 (около 617 цифр)».

Каким бы сильным алгоритмом ни был GNFS, считается, что даже для взлома 270-значного числа (RSA-270) потребовались бы тысячи, а то и десятки тысяч лет, даже если бы объединили все компьютеры мира. На данный момент наши данные в LINE и банках в безопасности.

Но что, если появится «магия, способная мгновенно находить $X$ и $Y$ для любого сколь угодно гигантского числа» ? На самом деле, самое близкое к этому — разрабатываемые сейчас «квантовые компьютеры (Алгоритм Шора)» . Математически доказано, что, используя волновую природу квантовой механики, можно проигнорировать утомительную головоломку со сбором карточек и вытянуть правильный ответ за один раз.

Бесконечная битва умов между создателями шифров (защитой) и создателями алгоритмов взлома (атакой). Когда узнаешь, что «разложение на простые множители» и «алгебраические выражения», которые изучают в средней школе, на самом деле являются оружием, ожесточенно сражающимся на переднем крае глобальной безопасности, разве уроки математики не начинают казаться чуточку интереснее?

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

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

Простое объяснение гипотезы Кеплера

Mon, 21 Jul 2025 22:53:03 +0900

Простое объяснение гипотезы Кеплера! 〜Как плотнее всего упаковать арбузы〜

Всем привет, это kenji!

Сегодня я хотел бы максимально просто рассказать о математической проблеме со сложным названием — «гипотеза Кеплера».

На первый взгляд это может показаться очень специфической темой, но на самом деле это довольно практичная задача: «как плотнее всего упаковать арбузы в коробку?». Она также имеет отношение к холодильникам в магазинах и к тому, как складывать грузы.

А в мире математики это супер-романтичная история о том, что никто не мог доказать это на протяжении более 400 лет .

Ну что, поехали!

Кто такой Кеплер?

Для начала, кто такой «Кеплер» из «гипотезы Кеплера»?

Это имя немецкого астронома и математика Иоганна Кеплера (Johannes Kepler) .

Этот человек был невероятно выдающимся. Например, именно он открыл, что орбиты планет имеют форму эллипса. Сегодня это общеизвестный факт, но в то время (около 1600 года) даже гелиоцентрическая система не пользовалась особым доверием.

Галилей = гений наблюдений
Кеплер = гений, описавший Вселенную формулами
Ньютон = супергений, объединивший эти теории в законы физики

В таком контексте Кеплер был пионером в том, чтобы «описывать Вселенную с помощью математики».

И вот однажды он заявил следующее.

Что такое гипотеза Кеплера?

Проще говоря, «гипотеза Кеплера» — это вот о чем.

Если мы упаковываем шары одинакового размера (например, арбузы или апельсины) в коробку, какой способ укладки позволит упаковать их плотнее всего?

Вот такая задача.

И Кеплер в 1600-х годах предположил следующее:

Разве не эффективнее всего складывать их треугольником, как это делают с апельсинами на рынке?

Говоря математическим языком, это называется «задача о плотнейшей упаковке» — поиск способа максимально плотно заполнить пространство шарами.

Кеплер предположил, что наиболее эффективным способом является «гранецентрированная кубическая решетка (ГЦК)» (примерно так же, как складывают арбузы треугольником).

И хотя все думали: «Да, это звучит правдоподобно», математически доказать, что «это абсолютно лучший вариант!», оказалось невероятно сложно.

400 лет до доказательства!?!

Итак, когда же это было окончательно доказано?

Удивительно, но это произошло примерно в 1998–2005 годах . То есть около 400 лет никто не мог этого доказать . Просто невероятно.

Более того, доказал её американский математик Томас Хейлс (Thomas Hales) .

Поняв, что вручную это вычислить невозможно, он использовал компьютер для доказательства . Однако доказательство оказалось настолько сложным, что люди не смогли его нормально проверить! Это вызвало проблему.

В математическом мире разгорелись бурные дебаты: «Можно ли доверять доказательству, выполненному на компьютере?».

В итоге в 2014 году было завершено «строгое доказательство, проверенное с учетом компьютера» (официально называемое «формальным доказательством»).

Это означает, что понадобилось более 400 лет , чтобы доказать правоту интуиции Кеплера. Настоящая романтика.

Это очень часто используется в реальной жизни

Можно подумать, что вопрос о том, «как складывать шары», волнует только математиков-гиков, но на самом деле это суперпрактично.

Эффективная расстановка напитков в холодильниках супермаркетов
Укладка консервных банок на транспортные поддоны
Применение в телекоммуникациях (например, для сжатия цифровых сигналов)
Использование при проектировании для 3D-принтеров и кристаллических структур

И многое другое — на самом деле эта теория активно применяется за кулисами нашей повседневной жизни.

Заключение: человеческая интуиция удивительна

Итак, подведем итоги.

Гипотеза Кеплера = задача о том, как наиболее плотно упаковать шары
Кеплер = математик и астроном, открывший орбиты планет
Гипотеза была выдвинута в 1600-х годах! А доказана только в 2000-х!
Она имеет множество применений в реальной жизни!

И самое интересное здесь то, что «способ укладки, который продавцы на рынке использовали интуитивно, оказался математически лучшим» .

Иными словами, человеческая интуиция поразительна . А тот факт, что на её доказательство может уйти 400 лет , делает эту историю по-настоящему романтичной.

Если вам это интересно, обязательно поищите информацию по запросам «Томас Хейлс», «формальное доказательство» и «Sphere Packing». Если копнуть глубже, это безумно интересно.

До встречи!

[PR]

今すぐ購入

Гипотеза Коллатца

Tue, 15 Jul 2025 18:03:03 +0900

“Действительно ли любое число в конце концов становится 1?” ── Играем с гипотезой Коллатца

Всем привет! Это Кенджи.

Внезапный вопрос: когда вы слышите о “правиле, по которому любое число в итоге превращается в 1”, разве это не кажется вам немного странным?

Например, 19, или 87, или даже 1000000. Если вы следуете определенному правилу и манипулируете числами, по какой-то причине они всегда сводятся к “1”.

Эта сказочная история и есть гипотеза Коллатца (Collatz Conjecture).

Для начала, что такое гипотеза Коллатца?

Сначала позвольте мне представить правила.

Старт: выберите любое положительное целое число
Операция:
- Если четное → делим пополам (n → n / 2)
- Если нечетное → умножаем на 3 и прибавляем 1 (n → 3n + 1)

Если повторять это снова и снова, гипотеза гласит, что любое число в конечном итоге достигнет 1.

Например, если мы начнем с 6:

1

6 → 3 → 10 → 5 → 16 → 8 → 4 → 2 → 1

Оно действительно стало “1”. С возвращением!

Давайте попробуем это в коде: Коллатц на Python

Что ж, в таких случаях быстрее всего попробовать написать код! Давайте выведем “последовательность Коллатца” с помощью Python.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


def collatz(n):
 steps = [n]
 while n != 1:
 if n % 2 == 0:
 n = n // 2
 else:
 n = 3 * n + 1
 steps.append(n)
 return steps

# Пример: давайте начнем с 19
print(collatz(19))

При запуске:

1

[19, 58, 29, 88, 44, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1]

Оно успешно достигает 1. Пришлось сделать немало крюков, но в итоге мы на финише!

Кстати, даже если мы начнем с 29, оно достигнет 1 таким же образом.

1

pythonprint(collatz(29))

При запуске:

1
2
3
4
5
6
7
8


[27, 82, 41, 124, 62, 31, 94, 47, 142, 71, 214, 107, 322, 161, 484, 242,
121, 364, 182, 91, 274, 137, 412, 206, 103, 310, 155, 466, 233, 700, 350,
175, 526, 263, 790, 395, 1186, 593, 1780, 890, 445, 1336, 668, 334, 167,
502, 251, 754, 377, 1132, 566, 283, 850, 425, 1276, 638, 319, 958, 479,
1438, 719, 2158, 1079, 3238, 1619, 4858, 2429, 7288, 3644, 1822, 911,
2734, 1367, 4102, 2051, 6154, 3077, 9232, 4616, 2308, 1154, 577, 1732,
866, 433, 1300, 650, 325, 976, 488, 244, 122, 61, 184, 92, 46, 23, 70, 35,
106, 53, 160, 80, 40, 20, 10, 5, 16, 8, 4, 2, 1]

На это уходит целых 111 шагов!

Более того, по пути оно иногда раздувается до более чем 9000. Это тот случай, когда перед финишем делается огромный крюк.

Итак, что же в итоге в этом такого удивительного?

Удивительное в этой гипотезе то, что:

Хотя это не доказано, похоже, что оно всегда сводится к 1, независимо от того, какое число вы берете

Вот в чем крутизна.

А? А как насчет триллиона или квадриллиона…?

Если вы подумали об этом, то вы очень проницательны. На самом деле, с помощью компьютеров это было проверено вплоть до “2 в 68-й степени”, и все они достигают 1. Невероятно…

Но не было теоретически доказано, что “все будет именно так”. Вот что называется “нерешенной проблемой” в мире математики.

Кто такой мистер Коллатц?

Итак, дочитав до этого места, вы, возможно, спросите: “Кто вообще такой Коллатц?” Я представлю его как следует!

Имя: Лотар Коллатц (Lothar Collatz)
Гражданство: Германия
Годы жизни: 1910 - 1990
Профессия: Математик (активно работал в области функционального анализа и теории чисел)

Он предложил эту гипотезу в 1937 году, и с тех пор, на протяжении более 80 лет, никто не смог ее ни доказать, ни опровергнуть.

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

“Математика еще не созрела для решения проблемы Коллатца.”

Иными словами, существует теория, что человеческая математика еще не доросла до этой загадки…

“Сложные формулы” не нужны

Прелесть гипотезы Коллатца в том, что каждый может с ней поиграть.

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

Разве это не захватывающе?

Бонус: Код для массовой проверки

Я также приложу код для проверки множества чисел за один раз.

1
2
3


for n in range(1, 21):
 steps = collatz(n)
 print(f"{n}: {steps} (количество шагов: {len(steps)-1})")

Этот код сразу выведет последовательности Коллатца для чисел от “1 до 20”.

Вывод: Этот мир действительно странный

Итак, это гипотеза Коллатца.

Хотя она очень проста
Никто не может ее доказать
Это огромная проблема в математическом мире

Она оказалась чем-то вроде сгустка тайн.

Даже новички в программировании могут попробовать ее, так что, пожалуйста, поиграйте!

Проблема P≠NP

Wed, 11 Sep 2024 02:22:39 +0900

Обзор

1

Класс P — это класс проблем, которые могут быть разрешены за полиномиальное время на детерминированной машине Тьюринга, а класс NP — это класс проблем, для которых, когда дается доказательство того, что ответ — «да» (называемое свидетелем), правильность свидетеля может быть проверена за полиномиальное время (это называется верификацией). Поскольку проблемы, разрешимые за полиномиальное время, также проверяемы за полиномиальное время, очевидно, что P⊆NP, но неясно, является ли P строгим подмножеством NP. Хотя доказательства еще нет, многие исследователи верят, что P≠NP. Это предположение о том, что класс P и класс NP не равны, называется "проблемой P≠NP".

Справочный сайт : https://daigakudenki.com/np-hard/

C-код для генерации простых чисел

Sat, 24 Aug 2024 09:38:10 +0900

Ниже приведен простой код на языке C, который генерирует простые числа в заданном диапазоне. В этом примере перечисляются простые числа от 1 до n.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


#include <stdio.h>
#include <stdbool.h>

bool isPrime(int num) {
 if (num <= 1) return false;
 if (num <= 3) return true;
 if (num % 2 == 0 || num % 3 == 0) return false;

 for (int i = 5; i * i <= num; i += 6) {
 if (num % i == 0 || num % (i + 2) == 0) return false;
 }
 return true;
}

void printPrimes(int n) {
 printf("2 ");
 for (int i = 3; i <= n; i += 2) {
 if (isPrime(i)) {
 printf("%d ", i);
 }
 }
 printf("\n");
}

int main() {
 int n;
 printf("Введите максимальное значение диапазона для генерации простых чисел: ");
 scanf("%d", &n);
 printf("Простые числа от 1 до %d следующие:\n", n);
 printPrimes(n);
 return 0;
}

Этот код работает следующим образом:

Функция isPrime: Определяет, является ли заданное число простым. Для эффективности сначала проверяется делимость на 2 и 3, а затем проверка продолжается с кратными 6.
Функция printPrimes: Выводит простые числа в заданном диапазоне. Сначала выводится 2, затем проверяются только нечетные числа.
Функция main: Запрашивает у пользователя максимальное значение диапазона и выводит простые числа в этом диапазоне.

При компиляции и выполнении этого кода будут отображены простые числа в заданном диапазоне.

Введение в Mathematica

Thu, 25 Jul 2024 01:36:19 +0900

Введение в Mathematica

Решение уравнений

1

Solve[x^2 - 3 x + 2 == 0, x]

Вывод

1

{{x -> 1}, {x -> 2}}

Поиск решений уравнений в целых числах

1

Solve[x^2 - 3 x + 2 == 0 && 0 <= x <= 2, x, Integers]

Вывод

1

{{x -> 1}, {x -> 2}}

Решение систем уравнений

1

Solve[{x + y == 3, x - y == 1}, {x, y}]

Вывод

1

{{x -> 2, y -> 1}}

Решение неравенств

1

Reduce[x^2 - 3 x + 2 > 0, x]

Вывод

1

x < 1 || x > 2

Дифференцирование

1

D[x^2, x]

Вывод

1

2 x

Интегрирование

1

Integrate[x^2, x]

Вывод

1

x^3/3

Вычисление пределов

1

Limit[1/x, x -> 0]

Вывод

1

Infinity

Вычисление рядов

1

Sum[1/n^2, {n, 1, Infinity}]

Вывод

1

π^2/6

Создание матриц

1

m = {{1, 2}, {3, 4}}

Умножение матриц

1

m . m

Вывод

1

{{7, 10}, {15, 22}}

Вычисление обратной матрицы

1

Inverse[m]

Вывод

1

{{-2, 1}, {1.5, -0.5}}

Поиск собственных значений и векторов

1

Eigensystem[m]

Вывод

1

{{5, 0}, {{1, 1}, {1, -1}}}

Скалярное произведение векторов

1

{1, 2} . {3, 4}

Вывод

1

11

Векторное произведение векторов

1

Cross[{1, 2, 3}, {4, 5, 6}]

Вывод

1

{-3, 6, -3}

Вычисление длины вектора

1

Norm[{1, 2, 3}]

Вывод

1

√14

Вычисление угла между векторами

1

ArcCos[{1, 2} . {3, 4}/(Norm[{1, 2}] Norm[{3, 4}])]

Вывод

1

ArcCos[11/(√5 √25)]

Проекция вектора

1

{1, 2} . {3, 4}/Norm[{3, 4}] {3, 4}/Norm[{3, 4}]

Вывод

1

{11/5, 22/5}

Вращение вектора

1

RotationMatrix[π/2].{1, 0}

Вывод

1

{0, 1}

Параллельный перенос вектора

1

TranslationTransform[{1, 2}][{3, 4}]

Вывод

1

{4, 6}

Масштабирование вектора

1

ScalingTransform[{2, 3}][{1, 1}]

Вывод

1

{2, 3}

Отражение вектора

1

ReflectionTransform[{1, 1}][{1, 1}]

Вывод

1

{0, 0}

Генерация случайных чисел

1

RandomReal[]

Вывод

1

0.123456

Генерация случайных чисел (целые числа)

1

RandomInteger[]

Вывод

1

123456

Генерация случайных чисел (с указанием диапазона)

1

RandomReal[{1, 10}]

Вывод

1

5.6789

Генерация случайных чисел (целые числа, с указанием диапазона)

1

RandomInteger[{1, 10}]

Вывод

1

5

Генерация случайных чисел (с указанием распределения)

1

RandomVariate[NormalDistribution[0, 1]]

Вывод

1

0.123456

Генерация случайных чисел (с распределением и количеством)

1

RandomVariate[NormalDistribution[0, 1], 10]

Вывод

1

{0.123456, 0.234567, ..., 0.987654}

Генерация случайных чисел (распределение, количество, seed)

1
2


SeedRandom[12345]
RandomVariate[NormalDistribution[0, 1], 10]

Вывод

1

{0.123456, 0.234567, ..., 0.987654}

Применение функции к элементам массива

1
2
3


Map[Sqrt, {1, 4, 9}]
Sqrt /@ {1, 4, 9}
Map[#^(1/2)&, {1, 4, 9}]

Вывод

1

{1, 2, 3}

Определение функции с помощью лямбда-выражения

1
2


f = Function[x, x^2]
f[3]

Вывод

1

9

Композиция функций

1
2
3
4


f = Function[x, x^2]
g = Function[x, x + 1]
h = Function[x, f[g[x]]]
h[3]

Вывод

1

16

Ссылка на результат предыдущего вычисления

1

% + 1

Вывод

1

17

Чистые функции

1

(#+3)&[5]

Вывод

1

8

Извлечение из массива

1
2


Select[{1, 2, 3, 4, 5}, EvenQ]
Select[{1, 2, 3, 4, 5}, Mod[#,2]==0&]

Вывод

1

{2, 4}

Что такое парадокс дней рождения?

Tue, 02 Apr 2024 01:20:50 +0900

Вы знаете о парадоксе дней рождения?

Я расскажу немного странную историю. Как вы думаете, сколько людей должно собраться, чтобы “вероятность того, что у кого-то совпадут дни рождения” стала высокой?

Например, в году 365 дней, поэтому когда говорят, что “если соберутся 23 человека, вероятность того, что у кого-то совпадет день рождения, составляет 50% или больше”… это кажется несколько противоречащим интуиции, не так ли?

Но это действительно больше 50%.

Почему так происходит?

Это явление называется “парадоксом дней рождения”. Название содержит слово “парадокс”, но для этого есть веская математическая причина.

Если количество людей обозначить как “n”, то вероятность того, что ни у кого не совпадет день рождения, можно вычислить по следующей формуле:

1

P(ни у кого не совпадает) = 365/365 × 364/365 × 363/365 × ... × (365 - n + 1)/365

Вычитая это из 1, мы получаем “вероятность совпадения с кем-то”.

Посмотрим на результаты…

Количество человек	Вероятность совпадения дней рождения
10 человек	Около 11.7%
20 человек	Около 41.1%
23 человека	Около 50.7% (Здесь внимание!)
30 человек	Около 70.6%
70 человек	Целых 99.9%!

Другими словами, если есть всего 23 человека, с вероятностью больше половины дни рождения кого-то совпадут. Кажется, это вполне применимо к школьным классам или рабочим совещаниям.

Заключение: разница между интуицией и математикой интересна

“Парадокс дней рождения” — это интересный пример того, как наша интуиция расходится с реальной математической вероятностью. Знание таких вещей может оживить небольшую беседу или викторину!

Полезные ссылки

Парадокс дней рождения (Википедия)

Парадокс Монти Холла

Sun, 31 Mar 2024 23:41:51 +0900

Что такое парадокс Монти Холла

Парадокс Монти Холла — это задача, основанная на игре из американского телешоу “Let’s Make a Deal”, которая выглядит следующим образом.

Исходные условия: за одной из трех дверей находится приз, а за двумя другими — ничего.

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

Задача состоит в том, чтобы решить, лучше ли участнику изменить свой выбор или нет.

Решение

Решение парадокса Монти Холла выглядит следующим образом.

Если участник не меняет дверь, которую он выбрал изначально
- Вероятность выигрыша: 1/3
- Вероятность проигрыша: 2/3
После того как ведущий открывает дверь без приза
- Если не менять выбор, вероятность выигрыша: 1/3 (остается такой же, как в п. 1)
- Если изменить выбор, вероятность выигрыша: 2/3 (вероятность того, что приз не был выбран изначально)

Следовательно, у участника больше шансов на выигрыш, если он изменит свой выбор.

Источники

Wikipedia Monty Hall problem

Нерешенные математические проблемы

Sat, 02 Mar 2024 22:57:36 +0900

Нерешенные математические проблемы

Мы расскажем о нерешенных математических проблемах. Хотя сами проблемы просты, существует еще много проблем, которые не доказаны.

Существует ли бесконечное множество совершенных чисел?

Совершенное число — это натуральное число, равное сумме всех своих собственных делителей (то есть делителей, отличных от самого числа). Например,

Делителями числа 6 являются 1, 2 и 3, а 1+2+3=6, поэтому это совершенное число.
Делителями числа 28 являются 1, 2, 4, 7 и 14, а 1+2+4+7+14=28, поэтому это совершенное число.

На данный момент обнаружено только 51 совершенное число. Хотя ожидается, что их бесконечно много, это еще не доказано.

Проблема Гольдбаха

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

Например,

4=2+2
6=3+3
8=3+5
10=3+7=5+5

Сама проблема очень проста, но она до сих пор не доказана.

Гипотеза Римана

Гипотеза утверждает, что нетривиальные нули дзета-функции Римана ограничиваются отрицательными четными числами и комплексными числами с действительной частью, равной 1 / 2.

Дзета-функция Римана $\zeta$ определяется следующим образом, где $s$ — комплексное число, а $n$ — натуральное число:

$$\zeta(s):=\sum _{n=1}^{\infty }{\frac {1}{n^{s}}}=1+{\frac {1}{2^{s}}}+{\frac {1}{3^{s}}}+{\frac {1}{4^{s}}}+\cdots$$

История математики

Sat, 22 Jul 2023 15:25:10 +0900

Три классические задачи на построение древней Греции

Построить квадрат, равновеликий по площади данному кругу (Квадратура круга)
Разделить произвольный заданный угол на три равные части (Трисекция угла)
Построить куб, объем которого в два раза больше объема заданного куба (Удвоение куба)

Архимедова спираль

На плоскости луч OB вращается вокруг фиксированной точки O с постоянной скоростью. Если начальное положение — OA, и точка P начинает движение от O вдоль OB с постоянной скоростью одновременно с началом вращения, то линия, которую описывает точка P, называется архимедовой спиралью.

Теорема Паппа

Циклоида
Конхоида Никомеда
Циссоида Диокла
Метод касательных Ферма
Метод нормалей Декарта

Хронология

Год	Событие
Около 3400 г. до н.э.	Шумеры используют глиняные жетоны для счета
Около 3000 г. до н.э.	Появление иероглифической математики в Египте
Около 2800 г. до н.э.	Индская цивилизация использует меры и веса на основе десятичной системы
Около 2700 г. до н.э.	Египтяне используют веревку и пифагоровы тройки для проверки углов
Около 2500 г. до н.э.	Обнаружен абак, инструмент для вычислений
Около 2500 г. до н.э.

Ссылки

История математики

Как найти простые числа до 1000 с помощью решета Эратосфена

Sun, 09 Apr 2023 12:54:24 +0900

Что такое решето Эратосфена

Решето Эратосфена — это алгоритм для нахождения всех простых чисел до заданного целого числа. Алгоритм прост и может быть реализован с помощью следующих шагов:

Создайте логический (bool) массив из N элементов и инициализируйте все элементы как true.
Установите 0-й и 1-й элементы массива как false (так как 0 и 1 не являются простыми числами).
Если 2-й элемент массива равен true, выведите 2 как простое число.
Установите все элементы, кратные 2, начиная с $2^2$, в false ※
Если 3-й элемент массива равен true, выведите 3 как простое число.
Установите все элементы, кратные 3, начиная с $3^2$, в false.
Повторите тот же процесс для 4-го, 5-го, …, N-го элементов.

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

Реализация на Rust

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


fn main() {
 let n = 1000;
 let mut is_prime = vec![true; n+1];
 is_prime[0] = false;
 is_prime[1] = false;
 for i in 2..=n {
 if is_prime[i] {
 println!("{}", i);
 let mut j = i * i;
 while j <= n {
 is_prime[j] = false;
 j += i;
 }
 }
 }
}

Немного более быстрая версия

Мы реализуем немного более быструю версию, учитывая следующие моменты:

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


fn main() {
 let n = 1000;
 let mut is_prime = vec![false; n+1];
 is_prime[2] = true;
 for i in (3..=n).step_by(2) {
 is_prime[i] = true;
 }
 for i in 3..=((n as f64).sqrt() as usize) {
 if is_prime[i] {
 let mut j = i * i;
 while j <= n {
 is_prime[j] = false;
 j += i * 2;
 }
 }
 }
 for i in (2..=n).filter(|&x| is_prime[x]) {
 println!("{}", i);
 }
}

Источники

Решето Эратосфена

Как рисовать графики с помощью Python (matplotlib.pyplot)

Sun, 09 Apr 2023 01:02:19 +0900

Требования

Аккаунт Google

Шаги

Перейдите на https://colab.research.google.com/
Выберите «Файл» → «Создать блокнот»
Вставьте и выполните следующий код

1
2
3
4
5
6
7


import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 2*np.pi, 500)
plt.plot(x, np.sin(x), label="sin curve")
plt.plot(x, np.cos(x), label="cos curve")
plt.legend() # отображение легенды
plt.show()

Результат

Ссылки

matplotlib.pyplot — Matplotlib 3.5.3 documentation

Как включить KaTeX (отображение формул в стиле LaTeX) в hugo

Fri, 31 Mar 2023 23:11:26 +0900

Что такое KaTeX?

KaTeX — это JavaScript-библиотека для отображения математических формул в стиле LaTeX в HTML.

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

$$f(x) = x^2 + x + 41$$

Существуют и другие библиотеки для отображения формул в стиле LaTeX, но KaTeX славится своей простотой и скоростью.

Как внедрить в hugo

Создайте новый файл layouts/partials/math.html в структуре папок hugo.

Содержимое должно быть следующим:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/katex@0.16.4/dist/katex.min.css" integrity="sha384-vKruj+a13U8yHIkAyGgK1J3ArTLzrFGBbBc0tDp4ad/EyewESeXE/Iv67Aj8gKZ0" crossorigin="anonymous">
<script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.4/dist/katex.min.js" integrity="sha384-PwRUT/YqbnEjkZO0zZxNqcxACrXe+j766U2amXcgMg5457rve2Y7I6ZJSm2A0mS4" crossorigin="anonymous"></script>
<script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.4/dist/contrib/auto-render.min.js" integrity="sha384-+VBxd3r6XgURycqtZ117nYw44OOcIax56Z4dCRWbxyPt0Koah1uHoK0o4+/RRE05" crossorigin="anonymous"></script>
<script>
document.addEventListener("DOMContentLoaded", function() {
 renderMathInElement(
 document.body,
 {
 delimiters: [
 {left: "$$", right: "$$", display: true},
 {left: "\\[", right: "\\]", display: true},
 {left: "$", right: "$", display: false},
 {left: "\\(", right: "\\)", display: false}
 ]
 });
 });
</script>

Затем добавьте следующий код в существующий файл layouts/partials/extend_head.html.

1
2
3


{{ if or .Params.math .Site.Params.math }}
{{ partial "math.html" . }}
{{ end }}

Теперь вы готовы использовать KaTeX.

Добавив math: true в front matter вашей страницы, вы сможете активировать KaTeX.

Все, что вам нужно сделать, это написать формулы в стиле LaTeX в теле вашей статьи.

1

$$ e^{i \pi} = -1 $$

При написании, как показано выше, это будет отображаться следующим образом:

$$ e^{i \pi} = -1 $$

Ссылки

Решение задачи коммивояжера с помощью Mathematica

Wed, 12 Oct 2022 19:05:58 +0900

Решение задачи коммивояжера с помощью Mathematica

Проблема

電車でこんな広告を見かけました😁📸 pic.twitter.com/iXEgvtXrpL
— 早稲田大学早水桃子研究室 (@hayamizu_lab) October 11, 2022

Решение

1

d=SparseArray[{{1,2}->10,{2,1}->10,{1,5}->15,{5,1}->15,{1,4}->12,{4,1}->12,{1,3}->20,{3,1}->20,{2,5}->10,{5,2}->10,{3,4}->10,{4,3}->10,{3,8}->30,{8,3}->30,{3,7}->20,{7,3}->20,{3,6}->25,{6,3}->25,{4,5}->15,{5,4}->15,{4,8}->20,{8,4}->20,{5,9}->18,{9,5}->18,{5,8}->15,{8,5}->15,{6,7}->5,{7,6}->5,{7,8}->35,{8,7}->35,{8,9}->12,{9,8}->12},{9,9},Infinity];

Создайте матрицу с помощью функции SparseArray. Каждый элемент представляет расстояние между городами в строке и столбце этого элемента. Например, первый элемент {1,2}->10 означает, что расстояние между 1 и 2 равно 10. Предпоследний элемент {9,9} указывает на размер матрицы, а последний элемент Infinity означает, что длина пути между неуказанными городами бесконечна. Другими словами, это означает, что пути нет.

1

{len,tour}=FindShortestTour[{1,2,3,4,5,6,7,8,9},DistanceFunction->(d[[#1,#2]]&)]

Вы можете легко решить задачу коммивояжера с помощью функции FindShortestTour. {1,2,3,4,5,6,7,8,9} представляют номера городов. DistanceFunction->(d[[#1,#2]]&) передает матрицу d, представляющую расстояния между городами.

Вывод

1

{137, {1, 2, 5, 9, 8, 7, 6, 3, 4}}

Выводом являются кратчайшее расстояние и маршрут в это время. Кратчайшее расстояние равно 137, а маршрут — 1→2→5→9→8→7→6→3→4→1. Если изменить порядок на ABC, он станет A, B, E, I, H, G, F, C, D.

Мои любимые математические формулы

Wed, 05 Oct 2022 13:24:50 +0900

Теорема Вильсона

Пусть $p$ — простое число, тогда выполняется $(p−1)!≡−1 \pmod p$

Формула Эйлера

$e^{iπ}+1=0$

Великая теорема Ферма

Для любого целого числа $n≥3$ не существует таких положительных целых чисел $x,y,z$, которые удовлетворяли бы уравнению $x^n+y^n=z^n$

Базельская проблема

$1/1^2+1/2^2+1/3^2+1/4^2+...=π^2/6$

Многочлен Эйлера для генерации простых чисел

$n^2+n+41$ дает простые числа для всех целых $n$ от $0$ до $39$

Математика on kenji.blog

【Полное понимание через формулы】 Почему сильнейший классический «GNFS» проигрывает квантовым алгоритмам? Смена парадигмы в факторизации

1. Подход к факторизации в классических вычислениях: развитие метода факторизации Ферма

2. Сильнейший классический алгоритм: Глубины “Общего метода решета числового поля” (GNFS)

Сложность GNFS

Математический механизм GNFS

2.1. Выбор многочленов и алгебраическое числовое поле

2.2. Просеивание (Sieving)

2.3. Редукция матрицы (Linear Algebra over GF(2))

2.4. Вычисление квадратного корня

3. Прорыв квантовых вычислений: “Алгоритм Шора”

Сложность Алгоритма Шора

Обзор Алгоритма Шора: Сведение к задаче поиска периода

4. Квантовое преобразование Фурье (QFT) и извлечение периода

4.1. Генерация квантовой суперпозиции

4.2. Применение Квантового преобразования Фурье (QFT)

4.3. Определение периода через разложение в цепную дробь

5. Сравнение концептуальных моделей и смена парадигмы

Концептуальная схема Алгоритма Шора с использованием квантовой схемы

Суть смены парадигмы

6. Заключение

"Полная анатомия" понимания сильнейшего алгоритма криптоанализа "GNFS" путем его реализации на C++

“Полная анатомия” понимания сильнейшего алгоритма криптоанализа “GNFS” путем его реализации на C++

1. Логический фреймворк GNFS (полный исходный код)

2. Конечная цель GNFS: $X^2 \equiv Y^2 \pmod N$

3. Фаза 1: Выбор полинома (Polynomial Selection)

4. Фаза 2: Решето на специальной q-решетке (Special-q Lattice Sieving)

5. Фаза 3: Фильтрация (Filtering)

6. Фаза 4: Линейная алгебра над GF(2) (метод Блока Видемана)

7. Фаза 5: Алгебраический квадратный корень (Algebraic Square Root) и крушение криптографии

Заключение

Истинная математическая структура общего метода решета числового поля (GNFS)

Истинная математическая структура общего метода решета числового поля (GNFS)

Этап 1: «Гомоморфизм» (Homomorphism), соединяющий миры

1. Выбор многочлена и определение корня

2. Построение кольца (Ring) и гомоморфизма

Этап 2: Крах разложения на простые множители и рождение «Идеала» (Ideal)

Спасение Куммера и Дедекинда: «Идеал»

Этап 3: Норма (Norm) и два решета (Sieve)

Этап 4: Два «Препятствия» и группа классов идеалов

Препятствие 1: Стена группы классов идеалов (Ideal Class Group)

Препятствие 2: Стена группы единиц (Unit Group)

Этап 5: Магия Адлемана «Квадратичные характеры» (Quadratic Characters)

Финальный этап: Слияние миров и взлом криптографии

Что такое Общий метод решета числового поля (GNFS) — сильнейшая математика человечества, взламывающая криптографию интернета?

Что такое Общий метод решета числового поля (GNFS) — сильнейшая математика человечества, взламывающая криптографию интернета?

Глава 1: Цель взлома — «формула из средней школы»

Почему «одинаковые остатки» могут взломать шифр?

Глава 2: Как найти X и Y? «Головоломка по сбору карточек с простыми числами»

Шаг 1: Просеивание только золотого песка (гладких чисел)

Шаг 2: Головоломка с приведением к «четному числу»

Глава 3: Стена отчаяния на пути

Глава 4: Гениальная идея человечества — создание «двух миров»

Магия алгебраических выражений

Поиск золотого песка одновременно в двух мирах

Момент взлома шифра

Заключение: Математика не заканчивается

Простое объяснение гипотезы Кеплера

Простое объяснение гипотезы Кеплера! 〜Как плотнее всего упаковать арбузы〜

Кто такой Кеплер?

Что такое гипотеза Кеплера?

400 лет до доказательства!?!

Это очень часто используется в реальной жизни

Заключение: человеческая интуиция удивительна

Гипотеза Коллатца

“Действительно ли любое число в конце концов становится 1?” ── Играем с гипотезой Коллатца

Для начала, что такое гипотеза Коллатца?

Давайте попробуем это в коде: Коллатц на Python

Итак, что же в итоге в этом такого удивительного?

Кто такой мистер Коллатц?

“Сложные формулы” не нужны

Бонус: Код для массовой проверки

Вывод: Этот мир действительно странный

Рекомендуемые ссылки (для тех, кому интересно)

Проблема P≠NP

Обзор

C-код для генерации простых чисел

Введение в Mathematica

Введение в Mathematica

Решение уравнений