Math on kenji.blog

【Для начинающих】Разбор математической структуры модели Transformer

Fri, 11 Sep 2026 22:00:00 +0900

Введение: зачем изучать математику Transformer?

Архитектура «Transformer» — это архитектура, о которой можно смело сказать, что она переписала историю современной обработки естественного языка (NLP) и ИИ в целом. Впервые предложенная в 2017 году исследователями Google в статье «Attention Is All You Need», эта модель функционирует как сердце крупномасштабных языковых моделей (LLM), которые сейчас доминируют в мире, таких как серия GPT от OpenAI (базовая технология ChatGPT), BERT от Google и Claude от Anthropic.

Однако, хотя часто встречаются качественные объяснения работы Transformer, такие как «понимание контекста с помощью механизма внимания (Attention)», на самом деле существует на удивление мало подробных объяснений математической структуры, стоящей за этим, для начинающих. Чтобы по-настоящему понять, как ИИ обрабатывает «слова» как «математические формулы» и генерирует удивительно естественные тексты, необходимо разобраться в его математических механизмах.

В этой статье мы подробно и доступно объясним математическую структуру, которая является сердцем Transformer: «Механизм внутреннего внимания (Self-Attention)», «Модель Запрос-Ключ-Значение (Q/K/V)», «Нормализация с помощью функции Softmax» и «Позиционное кодирование (Positional Encoding)». Статья предназначена для тех, кто обладает базовыми знаниями в области математики и программирования (понимает концепции матриц и производных на уровне старшей школы).

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

1. Ограничения традиционных методов и инновационность Transformer

До появления Transformer в обработке естественного языка доминировали рекуррентные нейронные сети (RNN) и их производные, такие как LSTM (Long Short-Term Memory). RNN были разработаны для обработки временных рядов данных и читают текст слово за словом с самого начала.

Однако у RNN было два фатальных недостатка:

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

Transformer полностью отбросил структуру RNN и произвел сдвиг парадигмы, используя исключительно «Attention» (внимание) для понимания контекста. Благодаря этому, независимо от длины последовательности, не происходит потери информации, а также становится возможным распараллеливание вычислений для максимального использования производительности GPU.

2. Общая архитектура Transformer

Сначала давайте взглянем на общую архитектуру Transformer. Transformer в общих чертах состоит из двух блоков: «Encoder» (кодировщик) и «Decoder» (декодировщик). На примере задачи перевода: Encoder преобразует исходный язык (например, английский) в математическое векторное представление, а Decoder на основе этого векторного представления генерирует целевой язык (например, японский/русский).

Следующая диаграмма представляет собой упрощенную внутреннюю структуру блока Encoder.

graph TD A["Входные токены"] --> B["Входное вложение"] B --> C["Позиционное кодирование"] C --> D["Многоголовое внутреннее внимание"] D --> E["Сложение и нормализация слоя"] E --> F["Сеть прямой связи"] F --> G["Сложение и нормализация слоя"] G --> H["Вывод на следующий слой"] C -.->|"Остаточное соединение"| E E -.->|"Остаточное соединение"| G

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

3. Векторизация слов и позиционное кодирование (Positional Encoding)

Компьютеры не могут понимать текст как таковой. Введенный текст сначала разбивается на единицы, называемые «токенами (Token)», и каждый из них преобразуется в вектор фиксированной длины. Это и есть Input Embedding.

3.1 Математика Input Embedding

Пусть размер словаря (vocabulary) равен $V$, а размерность вектора вложения (embedding) равна $d_{model}$ (в оригинальной статье $d_{model} = 512$). Каждое слово $w_i$ преобразуется в вектор $x_i \in \mathbb{R}^{d_{model}}$ с использованием матрицы вложения $W_E \in \mathbb{R}^{V \times d_{model}}$.

$$ x_i = W_E \cdot \text{one\_hot}(w_i) $$

Таким образом, весь текст представляется как матрица $X \in \mathbb{R}^{N \times d_{model}}$ (где $N$ — длина текста).

3.2 Необходимость и формулы позиционного кодирования (Positional Encoding)

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

Чтобы предоставить модели эту информацию о порядке слов, было придумано Positional Encoding. Позиционное кодирование $PE$ для $i$-го измерения слова, находящегося в позиции $pos$, вычисляется с использованием следующих тригонометрических функций:

$$ PE_{(pos, 2i)} = \sin\left(\frac{pos}{10000^{2i/d_{model}}}\right) $$ $$ PE_{(pos, 2i+1)} = \cos\left(\frac{pos}{10000^{2i/d_{model}}}\right) $$

Где $pos$ — это позиция слова ($0, 1, 2, \dots, N-1$), а $i$ — индекс размерности вектора ($0, 1, \dots, d_{model}/2 - 1$).

Почему используются синус и косинус?

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

Вспомните теоремы сложения для тригонометрических функций, которые изучают в старшей школе:

$$ \sin(\alpha + \beta) = \sin\alpha \cos\beta + \cos\alpha \sin\beta $$ $$ \cos(\alpha + \beta) = \cos\alpha \cos\beta - \sin\alpha \sin\beta $$

Позиционное кодирование для позиции $pos + k$, сдвинутой на $k$ относительно позиции $pos$, может быть представлено как линейная комбинация позиционного кодирования позиции $pos$. Другими словами, используя матрицу $M_k$, это можно записать следующим образом:

$$ PE_{pos+k} = M_k \cdot PE_{pos} $$

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

Итоговая входная матрица $X_{input}$ представляет собой сумму вектора вложения слов и этого позиционного кодирования.

$$ X_{input} = X + PE $$

4. Глубокая математика внутреннего внимания (Self-Attention)

Наконец-то мы переходим к самому важному компоненту Transformer — Self-Attention (Механизм внутреннего внимания). Цель Self-Attention — «вычислить степень связи между всеми словами в тексте и обновить вектор каждого слова до более богатого представления с учетом контекста».

Здесь используется аналогия с «поисковой системой»:

Query (Q): Запрос (поисковый запрос). «Какую информацию я сейчас ищу?»
Key (K): Ключ (заголовок). «Какая информация у меня есть?»
Value (V): Значение (сущность). «Какую информацию я на самом деле предоставляю?»

4.1 Создание матриц $Q, K, V$

Для входной матрицы $X \in \mathbb{R}^{N \times d_{model}}$ (для упрощения мы здесь игнорируем размер батча (batch size)), умножая на обучаемые весовые матрицы $W^Q, W^K, W^V \in \mathbb{R}^{d_{model} \times d_k}$, мы вычисляем запрос $Q$, ключ $K$ и значение $V$. (Обычно $d_k = d_v = d_{model} / h$)

$$ Q = X W^Q $$ $$ K = X W^K $$ $$ V = X W^V $$

Здесь $Q, K, V$ — все являются матрицами $\mathbb{R}^{N \times d_k}$.

4.2 Вычисление оценки внимания (Attention Score) - Скалярное произведение

Чтобы измерить, насколько Query каждого слова связан с Key всех остальных слов, мы вычисляем скалярное произведение векторов. В матричном виде это записывается следующим образом:

$$ \text{Scores} = Q K^T $$

Каждый элемент $s_{ij}$ полученной таким образом матрицы $\text{Scores} \in \mathbb{R}^{N \times N}$ представляет собой скалярное произведение Query $i$-го слова и Key $j$-го слова, то есть «силу связи».

4.3 Масштабирование (Scale)

При вычислении оценки (score) с помощью скалярного произведения возникает одна проблема. Если размерность вектора $d_k$ становится большой, значение скалярного произведения может стать экстремально большим или маленьким.

Давайте докажем это математически. Предположим, что каждый элемент запроса $q \sim \mathcal{N}(0, 1)$ и каждый элемент ключа $k \sim \mathcal{N}(0, 1)$ следуют независимому стандартному нормальному распределению. Найдем среднее и дисперсию скалярного произведения $q \cdot k = \sum_{i=1}^{d_k} q_i k_i$. Среднее: Так как $\mathbb{E}[q_i k_i] = \mathbb{E}[q_i] \mathbb{E}[k_i] = 0 \times 0 = 0$, среднее суммы также равно $0$. Дисперсия: Из независимости дисперсия $q_i k_i$ равна $\text{Var}(q_i k_i) = \mathbb{E}[(q_i k_i)^2] - (\mathbb{E}[q_i k_i])^2 = 1 \times 1 - 0 = 1$. Следовательно, дисперсия всего скалярного произведения будет равна размерности $d_k$.

$$ \text{Var}(q \cdot k) = d_k $$

Когда дисперсия становится большой, градиенты функции Softmax, применяемой после этого, становятся экстремально маленькими для значений, отличных от максимального, происходит «исчезновение градиента», и обучение останавливается. Чтобы предотвратить это, оценка (score) делится (масштабируется) на $\sqrt{d_k}$, чтобы дисперсия всегда оставалась равной $1$.

$$ \text{Scaled Scores} = \frac{Q K^T}{\sqrt{d_k}} $$

4.4 Преобразование в вероятности с помощью функции Softmax

К полученным оценкам по строкам применяется функция Softmax, чтобы преобразовать их в распределение вероятностей (веса), сумма которых равна $1$.

$$ a_{ij} = \text{softmax}(s_i)_j = \frac{\exp(s_{ij} / \sqrt{d_k})}{\sum_{m=1}^N \exp(s_{im} / \sqrt{d_k})} $$

Матрица $A \in \mathbb{R}^{N \times N}$ называется матрицей весов внимания (Attention Weight). Глядя на каждую строку $i$ этой матрицы, мы видим значения от 0 до 1, которые показывают, «насколько много внимания (Attention) следует уделить любому другому слову $j$ для понимания слова $i$».

4.5 Взвешенная сумма Value

Наконец, используя полученную матрицу весов внимания $A$, вычисляется взвешенная сумма матрицы Value $V$.

$$ \text{Output} = A V = \text{softmax}\left(\frac{Q K^T}{\sqrt{d_k}}\right) V $$

Матрица $Z \in \mathbb{R}^{N \times d_v}$, полученная в результате этой операции, представляет собой набор «векторных представлений слов, обновленных с учетом контекста». Это и есть полная картина Scaled Dot-Product Attention, определенная в оригинальной статье.

5. Multi-Head Attention (Многоголовое внимание)

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

Ранее описанные процессы генерации $Q, K, V$ и вычисления Attention выполняются параллельно $h$ раз (количество голов, в оригинальной статье $h=8$).

$$ \text{head}_i = \text{Attention}(X W_i^Q, X W_i^K, X W_i^V) $$

Здесь $W_i^Q, W_i^K, W_i^V \in \mathbb{R}^{d_{model} \times d_k}$ — обучаемые весовые матрицы, специфичные для $i$-й головы.

Результаты $\text{head}_i \in \mathbb{R}^{N \times d_v}$, выведенные каждой головой, объединяются (Concatenate) по горизонтали.

$$ \text{Concat}(\text{head}_1, \dots, \text{head}_h) \in \mathbb{R}^{N \times (h \cdot d_v)} $$

Поскольку обычно устанавливается так, что $h \cdot d_v = d_{model}$, размерность после объединения возвращается к исходной $d_{model}$. Наконец, эта матрица умножается на весовую матрицу $W^O \in \mathbb{R}^{d_{model} \times d_{model}}$ для получения окончательного вывода.

$$ \text{MultiHead}(Q, K, V) = \text{Concat}(\text{head}_1, \dots, \text{head}_h) W^O $$

graph TD X["Вход X"] --> Q1["Q1"] X --> K1["K1"] X --> V1["V1"] Q1 & K1 & V1 --> H1["Голова 1"] X --> Q2["Q2"] X --> K2["K2"] X --> V2["V2"] Q2 & K2 & V2 --> H2["Голова 2"] X --> QN["..."] X --> KN["..."] X --> VN["..."] QN & KN & VN --> HN["Голова h"] H1 & H2 & HN --> C["Объединить"] C --> WO["Умножить на WO"] WO --> OUT["Многоголовый вывод"]

6. Сеть прямой связи (Feed-Forward Neural Network, FFN)

Вывод Multi-Head Attention затем передается в Position-wise Feed-Forward Network (FFN). Это двухслойная полносвязная нейронная сеть, применяемая «независимо к каждой позиции (слову)» в последовательности.

В виде формулы это выражается следующим образом:

$$ \text{FFN}(x) = \max(0, x W_1 + b_1) W_2 + b_2 $$

Где $\max(0, z)$ представляет функцию активации ReLU (Rectified Linear Unit) (в недавних моделях также часто используются GELU или SwiGLU).

Роль этой сети чрезвычайно важна. В то время как механизм Attention изучает «отношения между словами (пространственные и последовательные отношения)», FFN отвечает за «нелинейное преобразование признаков каждого вектора слова самого по себе». Обычно вес первого слоя $W_1$ временно значительно увеличивает размерность (например, в 4 раза с $d_{model}=512$ до $d_{ff}=2048$), выполняет сложные вычисления в пространстве признаков, а затем вес второго слоя $W_2$ возвращает её к исходной размерности. Благодаря этому «расширению и сжатию размерности» выразительная сила модели резко возрастает.

7. Остаточное соединение (Residual Connection) и Нормализация слоя (Layer Normalization)

В глубоком обучении по мере углубления слоев сети возникает проблема исчезновения или взрыва градиентов во время обучения, из-за чего обучение проходит неудачно. Для предотвращения этого вокруг каждого подслоя (Attention и FFN) в Transformer размещены Остаточное соединение (Residual Connection) и Нормализация слоя (Layer Normalization).

В виде формулы вывод подслоя обрабатывается следующим образом:

$$ \text{Output} = \text{LayerNorm}(x + \text{Sublayer}(x)) $$

7.1 Остаточное соединение ($x + \text{Sublayer}(x)$)

Вход $x$ напрямую прибавляется к выводу подслоя. Благодаря этому при обратном распространении ошибки градиенты напрямую передаются в более мелкие слои по короткому пути, что стабилизирует обучение даже при глубокой структуре слоев.

7.2 Математика нормализации слоя (Layer Normalization)

Layer Normalization — это технология, которая вычисляет среднее и дисперсию по направлению размерности признаков и нормализует данные. Для входа с размером батча $B$, длиной последовательности $N$ и размерностью $d_{model}$, нормализация выполняется для одного вектора слова $x \in \mathbb{R}^{d_{model}}$.

Вычисляются среднее $\mu$ и дисперсия $\sigma^2$:

$$ \mu = \frac{1}{d_{model}} \sum_{i=1}^{d_{model}} x_i $$ $$ \sigma^2 = \frac{1}{d_{model}} \sum_{i=1}^{d_{model}} (x_i - \mu)^2 $$

Затем получается нормализованный вывод $\hat{x}$:

$$ \text{LN}(x) = \frac{x - \mu}{\sqrt{\sigma^2 + \epsilon}} \odot \gamma + \beta $$

(где $\epsilon$ — малая константа для предотвращения деления на ноль, а $\gamma, \beta$ — обучаемые параметры масштаба и сдвига)

Причина выбора нормализации по слоям (Layer Normalization) вместо нормализации по батчам (Batch Normalization) заключается в том, что при обработке данных последовательностей переменной длины, таких как текст, статистические показатели между батчами становятся нестабильными. Благодаря Layer Normalization, Transformer может обучаться стабильно независимо от размера батча.

8. Специфическая структура декодера: Masked Attention и Cross-Attention

Описанная до сих пор структура принадлежит кодировщику. В блоке декодера, генерирующем текст, структура немного отличается.

8.1 Masked Multi-Head Attention

Роль декодера заключается в «предсказании следующего слова на основе предыдущих слов». Следовательно, во время обучения недопустимо заглядывать в «будущие слова», иначе это будет похоже на списывание. Математическая операция, предотвращающая это, называется Masking (Маскирование).

К матрице оценок $Q K^T$ прибавляется матрица маски $M$, в которой верхнетреугольная часть (соответствующая будущей информации) заполнена очень маленькими значениями, близкими к $-\infty$.

$$ M_{ij} = \begin{cases} 0 & (i \le j) \\ -\infty & (i > j) \end{cases} $$ $$ \text{Masked Attention}(Q, K, V) = \text{softmax}\left(\frac{Q K^T + M}{\sqrt{d_k}}\right) V $$

При вычислении функции Softmax $\exp(-\infty) = 0$, поэтому веса внимания (Attention Weight) для будущих слов становятся полностью равными $0$. Это обеспечивает авторегрессионную генерацию с сохранением причинно-следственной связи (Causality).

8.2 Encoder-Decoder Cross-Attention

Второй подслой декодера — это Cross-Attention, который обращается к выводу кодировщика. Здесь $Q$ генерируется из предыду слоя декодера, а $K$ и $V$ генерируются из вывода последнего слоя кодировщика.

$$ Q_{decoder} = X_{dec} W^Q $$ $$ K_{encoder} = X_{enc} W^K $$ $$ V_{encoder} = X_{enc} W^V $$

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

9. Вычислительная сложность и математика оптимизации в современную эпоху

Transformer — великолепная модель, но из-за ее математической структуры у нее есть свои «слабые стороны». Обратите внимание на вычислительную сложность Self-Attention. При вычислении матрицы оценок $Q K^T$ матрица размера $(N \times d_k)$ умножается на матрицу размера $(d_k \times N)$, поэтому вычислительная сложность составляет $O(N^2 \cdot d_{model})$.

Другими словами, вычислительная сложность и использование памяти растут квадратично относительно длины последовательности $N$. Это не проблема для коротких текстов, но если попытаться ввести в LLM длинный контекст, например целую книгу, $N$ достигнет десятков или сотен тысяч, и память GPU мгновенно исчерпается при традиционных вычислениях Attention.

Чтобы разорвать это проклятие $O(N^2)$, в последние годы были предложены различные оптимизации с точки зрения математики и аппаратного обеспечения. Типичным примером является FlashAttention. FlashAttention — это алгоритм, который делит вычисления Attention на плитки (Tiling), чтобы минимизировать передачу данных (доступ к памяти) между иерархиями памяти GPU (SRAM и HBM). Хотя математически он выдает точно такой же результат, как стандартный Attention (Exact Attention), оптимизация на аппаратном уровне обеспечивает резкое ускорение и сокращение используемой памяти, что сделало возможным создание моделей с длинным контекстом, таких как GPT-4.

Кроме того, активно ведутся исследования таких подходов, как Sparse Attention и Linear Attention, которые аппроксимируют вычислительную сложность до $O(N \log N)$ или $O(N)$.

10. Пример реализации (псевдокод в стиле PyTorch)

Если перевести описанную математическую структуру в реальный программный код (Python / PyTorch), то окажется, что она описывается удивительно просто. Вот псевдокод ядра Self-Attention.

 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


import torch
import torch.nn.functional as F
import math

def scaled_dot_product_attention(q, k, v, mask=None):
 # форма q, k, v: [batch_size, num_heads, seq_length, d_k]
 d_k = q.size(-1)

 # 1. Вычисление оценки скалярным произведением: Q * K^T
 # Транспонируем последние два измерения для умножения матриц
 scores = torch.matmul(q, k.transpose(-2, -1))

 # 2. Масштабирование
 scores = scores / math.sqrt(d_k)

 # 3. Маскирование (в случае Masked Attention)
 if mask is not None:
 scores = scores.masked_fill(mask == 0, -1e9)

 # 4. Преобразование в вероятности с помощью Softmax
 attention_weights = F.softmax(scores, dim=-1)

 # 5. Умножение на матрицу Value
 output = torch.matmul(attention_weights, v)

 return output, attention_weights

Как можно видеть, формула $Q K^T / \sqrt{d_k}$ интуитивно реализована как torch.matmul(q, k.transpose(-2, -1)) / math.sqrt(d_k). Тот факт, что математическая теория реализуется в несколько строк кода с помощью продвинутых библиотек оптимизации, является очень интересным аспектом глубокого обучения.

Заключение: форма «интеллекта», видимая через формулы

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

Embedding, отображающий слова в многомерное векторное пространство, Positional Encoding, выражающее информацию о позиции через сложение тригонометрических волн, и механизм Self-Attention, который представляет собой вычисление скалярного произведения матриц, рожденное из аналогии с информационным поиском. Каждый из этих компонентов — не более чем наложение базовой математики: линейной алгебры, дифференциального и интегрального исчисления, а также теории вероятностей и статистики.

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

Как и предполагает провокационное название «Attention Is All You Need» (Внимание - это все, что вам нужно), красота этой архитектуры, отбросившей сложную рекуррентную и сверточную обработку и специализирующейся исключительно на вычислении «внимания (степени связи)», заключается именно в ее математической простоте.

Возможно, в будущем появятся новые архитектуры, превосходящие Transformer (например, Mamba, являющаяся State Space Model), но математическая база «понимания контекста с помощью Attention», созданная Transformer, навсегда останется в истории ИИ.

Если у вас будет возможность использовать LLM, такие как ChatGPT или Claude в будущем, представьте себе, как в фоновом режиме каждую секунду вычисляются триллионы матричных умножений $Q K^T$, а функция Softmax выдает вероятности. Разрешение вашего понимания технологий повысится, и мир ИИ покажется вам еще более интересным.

Литература

Vaswani, A., et al. (2017). “Attention Is All You Need.” Advances in Neural Information Processing Systems.
Alammar, J. (2018). “The Illustrated Transformer.”

Эта статья была написана как руководство для тех, кто изучает математические основы обработки естественного языка и ИИ. Если у вас есть вопросы или вы хотите что-то обсудить, пожалуйста, дайте знать в комментариях!

Основы и реализация криптографии с использованием малой теоремы Ферма

Fri, 11 Sep 2026 22:00:00 +0900

1. Введение: Тайна математики, лежащая в основе современной криптографии

В современном цифровом обществе, особенно в связи с передачей данных через Интернет, «криптография» стала неотъемлемой базовой технологией. То, что мы можем безопасно просматривать веб-сайты через HTTPS в веб-браузерах, совершать финансовые операции в онлайн-банкинге и приватно общаться в приложениях для обмена сообщениями, возможно благодаря криптографическим протоколам, работающим в фоновом режиме и опирающимся на продвинутую математическую теорию. Среди них особо важную роль играет «криптография с открытым ключом», ярким представителем которой является алгоритм RSA.

Безопасность и корректность многих криптографических алгоритмов, включая RSA, во многом зависят от очень красивой и мощной теоремы, открытой в 17 веке французским математиком Пьером де Ферма (Pierre de Fermat). Это Малая теорема Ферма (Fermat’s Little Theorem). Кроме того, теорема Леонарда Эйлера (Leonhard Euler), которая является ее обобщением, также играет решающую роль в теории криптографии.

В этой статье подробно и с самых основ объясняется, как открытие из области чистой математики, такое как малая теорема Ферма, применяется в современных практических криптографических технологиях, в частности, для «проверки на простоту» и в «алгоритме RSA». Это очень подробное техническое руководство, охватывающее математические доказательства, механизмы шифрования и дешифрования, а также конкретные реализации алгоритмов на C++ и Python.

2. Основы сравнений и модульной арифметики

Чтобы понять малую теорему Ферма, сначала необходимо ознакомиться с математической концепцией «модульной арифметики (сравнений по модулю)». Модульная арифметика — это система вычислений, в которой основное внимание уделяется «остатку» от деления на определенное заданное число (называемое модулем). Поскольку вычисления похожи на циферблат часов (который делает полный оборот за 12 часов), ее также называют «арифметикой часов».

Когда остатки от деления целых чисел $a$ и $b$ на положительное целое число $n$ равны, математически это записывается следующим образом:

$$ a \equiv b \pmod n $$

Это читается как «$a$ и $b$ сравнимы по модулю $n$». Например, остаток от деления 17 на 5 равен 2, и остаток от деления 12 на 5 также равен 2. Поэтому мы можем записать:

$$ 17 \equiv 12 \pmod 5 \equiv 2 \pmod 5 $$

В модульной арифметике обычные четыре арифметических действия (сложение, вычитание, умножение) работают так же:

Сложение: Если $a \equiv b \pmod n$ и $c \equiv d \pmod n$, то $a + c \equiv b + d \pmod n$
Вычитание: Если $a \equiv b \pmod n$ и $c \equiv d \pmod n$, то $a - c \equiv b - d \pmod n$
Умножение: Если $a \equiv b \pmod n$ и $c \equiv d \pmod n$, то $a \times c \equiv b \times d \pmod n$
Возведение в степень: Если $a \equiv b \pmod n$, то для любого натурального числа $k$ верно $a^k \equiv b^k \pmod n$

Однако с делением следует быть осторожными. В общем случае, из того, что $a \times c \equiv b \times c \pmod n$, нельзя разделить обе части на $c$ и получить $a \equiv b \pmod n$. Это справедливо только в том случае, когда $c$ и $n$ взаимно просты (их наибольший общий делитель равен 1). Эта концепция «модульного обратного элемента» станет чрезвычайно важной при генерации ключей RSA, которая будет обсуждаться позже.

3. Математические основы и доказательство малой теоремы Ферма

Теперь, когда мы усвоили основы модульной арифметики, давайте перейдем к главной теме — малой теореме Ферма.

3.1 Определение теоремы

Малая теорема Ферма формулируется следующим образом:

Малая теорема Ферма (Fermat’s Little Theorem) Пусть $p$ — простое число, а $a$ — любое целое число, не кратное $p$ (то есть $a$ и $p$ взаимно просты). Тогда справедливо следующее сравнение:
$$ a^{p-1} \equiv 1 \pmod p $$

Также часто встречается форма, в которой условие «$a$ не кратно $p$» убирается, и теорема выражается в виде, справедливом для всех целых чисел $a$. В этом случае, если умножить обе части на $a$, мы получим:

$$ a^p \equiv a \pmod p $$

3.2 Проверка на конкретных примерах

Давайте проверим на конкретных числах, действительно ли работает эта теорема. Пусть простое число $p = 5$. Тогда $p-1 = 4$. В качестве $a$ выберем целые числа, не кратные $p$.

Для $a = 2$: $2^{5-1} = 2^4 = 16$. $16 \div 5 = 3$ с остатком $1$. Следовательно, $16 \equiv 1 \pmod 5$. (Выполняется)
Для $a = 3$: $3^{5-1} = 3^4 = 81$. $81 \div 5 = 16$ с остатком $1$. Следовательно, $81 \equiv 1 \pmod 5$. (Выполняется)
Для $a = 4$: $4^{5-1} = 4^4 = 256$. $256 \div 5 = 51$ с остатком $1$. Следовательно, $256 \equiv 1 \pmod 5$. (Выполняется)

Таким образом, какое бы $a$ мы ни выбрали (при условии, что оно не кратно 5), остаток от деления 4-й степени на 5 всегда будет равен 1. Это выглядит как магия, но проистекает из прекрасных свойств простых чисел.

3.3 Математическое доказательство теоремы

Почему же это справедливо? Здесь мы приведем элегантное доказательство с использованием множества классов вычетов.

Рассмотрим множество $S = \{1, 2, 3, \dots, p-1\}$. Это представители целых чисел, остатки от деления которых на $p$ находятся в диапазоне от $1$ до $p-1$. Теперь рассмотрим новое множество $T$, полученное умножением каждого элемента на целое число $a$, взаимно простое с $p$:

$$ T = \{1a, 2a, 3a, \dots, (p-1)a\} $$

Рассмотрим остатки от деления каждого элемента множества $T$ на $p$. Удивительно, но эти остатки (возможно, в другом порядке) полностью совпадают с множеством элементов исходного множества $S$. Это происходит потому что:

Никакой элемент $T$ не может быть кратен $p$ (так как ни $a$, ни исходные элементы не кратны $p$).
В $T$ не существует двух различных элементов, сравнимых по модулю $p$. Если бы $ia \equiv ja \pmod p$ (при $i \neq j$), то, поскольку $a$ и $p$ взаимно просты, мы могли бы разделить обе части на $a$, получив $i \equiv j \pmod p$, что является противоречием.

Таким образом, произведение всех элементов множества $S$ сравнимо с произведением всех элементов множества $T$ по модулю $p$:

$$ (1a) \times (2a) \times \dots \times ((p-1)a) \equiv 1 \times 2 \times \dots \times (p-1) \pmod p $$

Если преобразовать левую часть, мы получим $p-1$ множителей $a$, поэтому:

$$ a^{p-1} \cdot (p-1)! \equiv (p-1)! \pmod p $$

Поскольку $(p-1)!$ взаимно просто с $p$, мы можем разделить обе части на $(p-1)!$, и в итоге выводится следующая теорема:

$$ a^{p-1} \equiv 1 \pmod p $$

Это и есть доказательство малой теоремы Ферма.

4. Функция Эйлера и теорема Эйлера

Малая теорема Ферма касается «простого числа $p$», но Леонард Эйлер обобщил ее для «любого положительного целого числа $n$». Это расширение необходимо для понимания алгоритма RSA.

4.1 Функция Эйлера $\phi(n)$

Функция Эйлера (также называемая тотиентом или $\phi$-функцией Эйлера) $\phi(n)$ представляет собой функцию, возвращающую «количество целых чисел от $1$ до $n$, взаимно простых с $n$».

В случае простого числа $p$ все целые числа от $1$ до $p-1$ взаимно просты с $p$, поэтому $\phi(p) = p - 1$.
Для двух различных простых чисел $p$ и $q$, в случае их произведения $n = p \times q$, $\phi(n)$ вычисляется по очень простой формуле: $$ \phi(p \times q) = \phi(p) \times \phi(q) = (p - 1)(q - 1) $$

Это свойство становится фундаментальной логикой при генерации ключей RSA.

4.2 Теорема Эйлера

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

Теорема Эйлера (Euler’s Theorem) Для любого положительного целого числа $n$ и взаимно простого с ним целого числа $a$ справедливо следующее:
$$ a^{\phi(n)} \equiv 1 \pmod n $$

Если $n$ — простое число $p$, то $\phi(p) = p - 1$, и это становится самой малой теоремой Ферма ($a^{p-1} \equiv 1 \pmod p$). Иными словами, малая теорема Ферма является лишь частным случаем теоремы Эйлера.

5. Поиск огромных простых чисел: Тест Ферма на простоту

В криптографических технологиях (таких как алгоритм RSA или обмен ключами Диффи-Хеллмана) необходимо быстро находить «огромные простые числа», длина которых может составлять сотни цифр. Однако, чтобы определить, является ли огромное число $N$ простым с помощью метода «перебора делителей» от $2$ до $\sqrt{N}$, потребовалось бы время, сравнимое с возрастом Вселенной.

И здесь на помощь приходит «вероятностный тест на простоту», использующий малую теорему Ферма наоборот. Он называется тест Ферма (Fermat Primality Test).

5.1 Что такое вероятностный тест на простоту

Согласно малой теореме Ферма, если $p$ — простое число, то для любого $a$ ($1 < a < p$) обязательно выполняется $a^{p-1} \equiv 1 \pmod p$. Если взять контрапозицию, то можно сказать: «Если для некоторого $a$ выполняется $a^{p-1} \not\equiv 1 \pmod p$, то $p$ абсолютно точно не является простым (является составным числом)».

Следовательно, если мы хотим проверить, является ли число $N$ простым, мы случайно выбираем несколько чисел $a$, вычисляем $a^{N-1} \pmod N$ и проверяем, равно ли это $1$. Если хотя бы раз ответ будет отличным от $1$, то точно установлено, что $N$ — составное число. Если же мы пробуем много раз и всегда получаем $1$, то с высокой долей вероятности можно судить, что $N$ «вероятно, простое».

5.2 Объяснение алгоритма и блок-схема

Алгоритм теста Ферма выглядит следующим образом:

flowchart TD Start["Начало"] --> Input["Ввести проверяемое число p и количество проверок k"] Input --> LoopStart["Цикл от i = 0 до k-1"] LoopStart --> Condition{"i < k ?"} Condition -- "Да" --> RandomA["Случайно выбрать целое число a в диапазоне 1 < a < p-1"] RandomA --> Calc["Вычислить модульное возведение в степень a^(p-1) mod p"] Calc --> CheckPrime{"Результат равен 1 ?"} CheckPrime -- "Нет" --> ReturnComposite["p является составным (точно)"] CheckPrime -- "Да" --> Increment["Увеличить i на 1"] Increment --> Condition Condition -- "Нет" --> ReturnPrime["p, вероятно, является простым (с высокой вероятностью)"] ReturnComposite --> End["Конец"] ReturnPrime --> End

5.3 Подводный камень: числа Кармайкла (псевдопростые)

Тест Ферма очень быстр, но у него есть один существенный недостаток. Существуют такие дьявольские числа, которые, будучи составными, удовлетворяют условию $a^{N-1} \equiv 1 \pmod N$ для всех возможных $a$. Такие числа называются числами Кармайкла (Carmichael numbers). Наименьшим числом Кармайкла является $561$ ($3 \times 11 \times 17$).

Из-за существования чисел Кармайкла только лишь с помощью теста Ферма нельзя абсолютно точно определить простоту числа. Поэтому в реальных криптографических системах (таких как OpenSSL) стандартно используется усовершенствованная версия теста Ферма — тест простоты Миллера-Рабина (Miller-Rabin Primality Test). Поскольку алгоритм Миллера-Рабина способен выявлять числа Кармайкла, вероятность ложного срабатывания может быть сведена практически к нулю.

5.4 Быстрое модульное возведение в степень (метод бинарного возведения в степень)

В алгоритме проверки на простоту необходимо вычислять $a^{N-1} \pmod N$, но если $N$ огромно, то $a^{N-1}$ будет иметь астрономическое количество цифр и не поместится в память компьютера. Решением этой проблемы является метод бинарного возведения в степень (Exponentiation by Squaring), или быстрое модульное возведение в степень. Путем взятия остатка (mod N) на каждом шаге вычисления значение всегда сохраняется меньше $N$, что позволяет выполнять вычисления очень быстро (со сложностью $O(\log N)$).

6. Реализация проверки на простоту и модульного возведения в степень

Теперь давайте реализуем тест Ферма на простоту и метод бинарного возведения в степень на C++ и Python.

6.1 Реализация на C++

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

 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


#include <iostream>
#include <random>

using namespace std;

// Быстрое модульное возведение в степень (a^b mod m) - метод бинарного возведения в степень
unsigned long long power_mod(unsigned long long a, unsigned long long b, unsigned long long m) {
 unsigned long long result = 1;
 a = a % m;
 while (b > 0) {
 // Если младший бит b равен 1, умножаем результат на a
 if (b % 2 == 1) {
 result = (__int128)result * a % m; // Расширение до 128 бит для предотвращения переполнения
 }
 // Возводим a в квадрат
 a = (__int128)a * a % m;
 // Сдвигаем b вправо (делим пополам)
 b /= 2;
 }
 return result;
}

// Тест Ферма на простоту
bool fermat_is_prime(unsigned long long p, int iterations = 5) {
 if (p <= 1) return false;
 if (p <= 3) return true;
 if (p % 2 == 0) return false;

 random_device rd;
 mt19937_64 gen(rd());
 uniform_int_distribution<unsigned long long> dis(2, p - 2);

 for (int i = 0; i < iterations; ++i) {
 unsigned long long a = dis(gen);
 // Если a^(p-1) mod p не равно 1, то это составное число
 if (power_mod(a, p - 1, p) != 1) {
 return false;
 }
 }
 return true; // Вероятно, простое
}

int main() {
 unsigned long long num = 1000000007; // Известное простое число
 if (fermat_is_prime(num, 10)) {
 cout << num << " is probably prime." << endl;
 } else {
 cout << num << " is composite." << endl;
 }
 return 0;
}

6.2 Реализация на Python

Стандартный целочисленный тип в Python поддерживает числа произвольной точности, поэтому не нужно беспокоиться о переполнении. Кроме того, встроенная функция Python pow(a, b, m) внутренне использует метод бинарного возведения в степень и работает очень быстро.

 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


import random

def fermat_is_prime(p, iterations=5):
 """
 Вероятностный тест на простоту с использованием теста Ферма
 """
 if p <= 1:
 return False
 if p <= 3:
 return True
 if p % 2 == 0:
 return False

 for _ in range(iterations):
 # Выбираем случайное число a от 2 до p-2
 a = random.randint(2, p - 2)
 # Вычисляем a^(p-1) mod p. Встроенная функция pow работает быстро.
 if pow(a, p - 1, p) != 1:
 return False # Точно составное число

 return True # Вероятно, простое

# Тестирование
number_to_test = 104729
if fermat_is_prime(number_to_test, 10):
 print(f"{number_to_test} вероятно, является простым.")
else:
 print(f"{number_to_test} является составным.")

7. Применение в алгоритме RSA: Место встречи Ферма и Эйлера

Самым великим применением малой теоремы Ферма (и теоремы Эйлера) является алгоритм RSA, разработанный в 1977 году Ривестом, Шамиром и Адлеманом. RSA — это инновационная криптографическая система с «открытым ключом», в которой ключ для шифрования (открытый ключ) доступен всему миру, а ключ для дешифрования (закрытый ключ) известен только самому получателю.

Эта асимметричность основана на вычислительной безопасности, обусловленной тем, что «разложение огромного составного числа на простые множители является чрезвычайно сложной задачей».

7.1 Механизм RSA (генерация ключей, шифрование, дешифрование)

Давайте рассмотрим весь процесс обмена данными в алгоритме RSA с помощью диаграммы последовательности Mermaid.

sequenceDiagram participant Alice["Алиса (Получатель)"] participant Bob["Боб (Отправитель)"] Alice->>Alice: "Сгенерировать огромные простые числа p, q" Alice->>Alice: "Вычислить N = p * q, φ(N) = (p-1)(q-1)" Alice->>Alice: "Вычислить открытый ключ e и закрытый ключ d (e*d ≡ 1 mod φ(N))" Alice->>Bob: "Отправить открытый ключ (N, e)" Note over Bob: "Подготовить открытый текст M (M < N)" Bob->>Bob: "Вычислить шифротекст C = M^e mod N" Bob->>Alice: "Отправить шифротекст C" Alice->>Alice: "Вычислить открытый текст M = C^d mod N и расшифровать"

Ниже описаны подробные математические шаги.

Шаг 1: Генерация ключей (действия получателя Алисы)

Случайным образом генерируются два огромных простых числа $p$ и $q$ (здесь используется упомянутый ранее тест на простоту).
Вычисляется их произведение $N = p \times q$. Это значение $N$ публикуется открыто.
Используя функцию Эйлера, вычисляется $\phi(N) = (p-1)(q-1)$.
Выбирается целое число $e$ (открытая экспонента), взаимно простое с $\phi(N)$ (часто используется $e = 65537$).
Вычисляется модульный обратный элемент $d$ (закрытая экспонента) для $e$. То есть, находится такое $d$, которое удовлетворяет условию: $$ e \cdot d \equiv 1 \pmod{\phi(N)} $$ Для этих вычислений используется расширенный алгоритм Евклида.

Таким образом, открытым ключом становится пара $(N, e)$, а закрытым ключом — пара $(N, d)$. (Значения $p, q, \phi(N)$ следует немедленно уничтожить или строго хранить в секрете).

Шаг 2: Шифрование (действия отправителя Боба)

Предположим, Боб хочет отправить Алисе сообщение $M$ (где $M$ — это преобразованный в числа текст, и $0 \le M < N$). Боб использует открытый ключ Алисы $(N, e)$ для вычисления шифротекста $C$ следующим образом:

$$ C \equiv M^e \pmod N $$

Затем этот $C$ передается Алисе по сети.

Шаг 3: Дешифрование (действия получателя Алисы)

Получив шифротекст $C$, Алиса использует свой закрытый ключ $d$, который знает только она, для выполнения следующего вычисления:

$$ M' \equiv C^d \pmod N $$

Поразительно, но результат этого вычисления $M'$ полностью совпадает с исходным сообщением $M$.

7.2 Почему возможна расшифровка? (Математическое доказательство)

Здесь малая теорема Ферма (и теорема Эйлера) проявляет свою истинную ценность. Почему $C^d \pmod N$ превращается обратно в $M$?

Давайте раскроем формулу дешифрования. Поскольку $C \equiv M^e \pmod N$, то:

$$ C^d \equiv (M^e)^d \equiv M^{ed} \pmod N $$

На шаге генерации ключей мы выбрали $d$ таким образом, что $e \cdot d \equiv 1 \pmod{\phi(N)}$. Это означает, что существует некоторое целое число $k$, при котором можно записать:

$$ e \cdot d = 1 + k \cdot \phi(N) $$

Подставим это в верхнюю формулу:

$$ M^{ed} = M^{1 + k \cdot \phi(N)} = M \cdot M^{k \cdot \phi(N)} = M \cdot (M^{\phi(N)})^k \pmod N $$

Здесь и появляется теорема Эйлера ($M^{\phi(N)} \equiv 1 \pmod N$). (※Строго говоря, $M$ и $N$ должны быть взаимно простыми, но в RSA вероятность того, что $M$ и $N$ не взаимно просты, астрономически мала, и, используя китайскую теорему об остатках, можно доказать, что это будет работать, даже если они не взаимно просты).

Применяя теорему Эйлера, так как $M^{\phi(N)} \equiv 1$, получаем:

$$ M \cdot (1)^k \equiv M \pmod N $$

$M$ чудесным образом восстановлено! Свойства чисел, открытые Ферма и Эйлером столетия назад, идеально гарантируют конфиденциальность современной цифровой связи.

8. Игрушечная реализация алгоритма RSA (Python)

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

Мы также включим в реализацию «расширенный алгоритм Евклида» для нахождения модульного обратного элемента $d$.

 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


import random

# Нахождение наибольшего общего делителя
def gcd(a, b):
 while b != 0:
 a, b = b, a % b
 return a

# Расширенный алгоритм Евклида (находим x, y для ax + by = gcd(a,b))
# Используется для нахождения d из e*d ≡ 1 (mod φ(N))
def extended_gcd(a, b):
 if a == 0:
 return (b, 0, 1)
 else:
 g, y, x = extended_gcd(b % a, a)
 return (g, x - (b // a) * y, y)

def mod_inverse(e, phi):
 g, x, y = extended_gcd(e, phi)
 if g != 1:
 raise Exception('Обратного элемента не существует')
 else:
 return x % phi

# Функция генерации простых чисел (упрощенная: генерирует небольшие простые числа)
def generate_prime(bits):
 while True:
 p = random.getrandbits(bits)
 # Упрощенная проверка вместо упомянутого ранее теста Ферма
 if p > 1 and pow(2, p-1, p) == 1 and pow(3, p-1, p) == 1:
 return p

# Генерация ключей RSA
def generate_keypair(bits=16):
 p = generate_prime(bits)
 q = generate_prime(bits)
 # Убедимся, что p и q не одинаковые
 while p == q:
 q = generate_prime(bits)

 n = p * q
 phi = (p - 1) * (q - 1)

 # Для e часто используют простые числа, например 65537, но здесь выберем случайно
 e = random.randrange(1, phi)
 g = gcd(e, phi)
 while g != 1:
 e = random.randrange(1, phi)
 g = gcd(e, phi)

 # Вычисление закрытого ключа d
 d = mod_inverse(e, phi)

 # Открытый ключ (e, n), Закрытый ключ (d, n)
 return ((e, n), (d, n))

def encrypt(pk, plaintext):
 e, n = pk
 # Вычисляем plaintext^e mod n
 cipher = [pow(ord(char), e, n) for char in plaintext]
 return cipher

def decrypt(sk, ciphertext):
 d, n = sk
 # Вычисляем cipher^d mod n и преобразуем обратно в символы
 plain = [chr(pow(char, d, n)) for char in ciphertext]
 return ''.join(plain)

# Пример выполнения
if __name__ == '__main__':
 print("--- Игрушечная реализация RSA ---")
 public_key, private_key = generate_keypair(bits=12) # Используем 12-битные простые числа

 print(f"Открытый ключ (e, n): {public_key}")
 print(f"Закрытый ключ (d, n): {private_key}")

 message = "Hello Math!"
 print(f"\nИсходное сообщение: {message}")

 # Шифрование
 encrypted_msg = encrypt(public_key, message)
 print(f"Шифротекст: {encrypted_msg}")

 # Дешифрование
 decrypted_msg = decrypt(private_key, encrypted_msg)
 print(f"Расшифрованное сообщение: {decrypted_msg}")

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

9. Заключение: Место пересечения красоты и практичности математики

Когда в 17 веке Пьер де Ферма открыл эту «малую теорему», никто не мог подумать, что она когда-нибудь пригодится. Сам Ферма занимался теорией чисел исключительно из чистого математического любопытства.

Однако почти 300 лет спустя, в 1970-х годах, на заре компьютерных сетей теорема Ферма совершила драматическое возрождение в качестве криптографической технологии, необходимой для создания безопасных протоколов связи. Метод проверки простоты, основанный на малой теореме Ферма, и алгоритм RSA, основанный на теореме Эйлера, буквально поддерживают инфраструктуру современного Интернета.

И сообщения в мессенджерах, которые мы отправляем каждый день, и покупки на Amazon — все это танцует на фундаменте одной простой и красивой формулы: $a^{p-1} \equiv 1 \pmod p$. Малая теорема Ферма учит нас тому, что независимо от того, насколько абстрактной может быть математика, однажды обязательно наступит время, когда она послужит человечеству.

При изучении программирования и теории криптографии понимание базовых математических структур станет для вас мощным инструментом. Это поможет глубоко понять поведение библиотек, предоставляемых в виде черных ящиков, и разрабатывать более безопасные системы.

Математическая интуиция криптографии на решетках (Lattice-based cryptography)

Fri, 11 Sep 2026 21:00:00 +0900

1. Введение: Рассвет постквантовой криптографии (PQC) и расцвет криптографии на решетках

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

Однако “алгоритм Шора”, опубликованный Питером Шором (Peter Shor) в 1994 году, потряс криптографический мир. Этот алгоритм математически доказал, что когда будут созданы крупномасштабные квантовые компьютеры, они смогут решать проблемы факторизации и дискретного логарифма за полиномиальное время. Это означает, что широко используемая сегодня криптография с открытым ключом в будущем станет полностью уязвимой для расшифровки.

Чтобы противостоять этой “квантовой угрозе” (Quantum Threat), возникла острая необходимость в исследовании новых методов шифрования, которые трудно взломать даже с помощью квантовых компьютеров. Эта область называется “постквантовой криптографией” (Post-Quantum Cryptography: PQC).

В PQC существует несколько перспективных кандидатов, таких как криптография на основе хешей, криптография на основе кодов, многомерная полиномиальная криптография и криптография на основе изогений. Однако “криптография на решетках” (Lattice-based cryptography) в настоящее время привлекает наибольшее внимание и является центральным элементом процесса стандартизации PQC Национальным институтом стандартов и технологий США (NIST). По сравнению с другими методами, криптография на решетках обладает чрезвычайно высокой скоростью шифрования и дешифрования, а также выдающейся особенностью: она имеет очень сильное доказательство безопасности в криптографии — сведение от “сложности в худшем случае” (Worst-case complexity) к “сложности в среднем случае” (Average-case complexity).

В этой статье мы подробно рассмотрим криптографию на решетках, начиная с математического определения “решетки” (Lattice), которая является ее основой. Мы обсудим сложные задачи на решетках, такие как SVP (задача поиска кратчайшего вектора) и CVP (задача поиска ближайшего вектора), а также проблему “LWE (Learning With Errors)”, которая является сердцем современной криптографии на решетках. Будут представлены математические формулы, геометрическая интуиция и конкретные числовые примеры.

2. Математическое определение решетки (Lattice) и геометрическая интуиция

2.1 Векторные пространства и решетки

В математике “решетка” (Lattice) — это множество дискретных точек, регулярно расположенных в $n$-мерном действительном векторном пространстве $\mathbb{R}^n$. Оно похоже на векторное пространство (Vector Space), изучаемое в линейной алгебре, но есть одно решающее отличие. В то время как векторное пространство — это непрерывное пространство, представленное линейными комбинациями базисных векторов с “действительными коэффициентами”, решетка — это дискретное пространство, представленное линейными комбинациями базисных векторов с “целыми коэффициентами”.

Дадим строгое математическое определение. Рассмотрим $n$ ($n \le m$) линейно независимых векторов $\mathbf{b}_1, \mathbf{b}_2, \dots, \mathbf{b}_n$ в $m$-мерном действительном векторном пространстве $\mathbb{R}^m$. Пусть матрица, содержащая эти векторы в качестве столбцов, будет $B = [\mathbf{b}_1, \mathbf{b}_2, \dots, \mathbf{b}_n] \in \mathbb{R}^{m \times n}$. Эта матрица $B$ называется “базисом” (Basis) решетки.

Решетка $\mathcal{L}(B)$, порожденная этим базисом $B$, определяется следующим образом:

$$ \mathcal{L}(B) = \left\{ \sum_{i=1}^{n} x_i \mathbf{b}_i \mathrel{\bigg|} x_i \in \mathbb{Z} \right\} = \{ B \mathbf{x} \mid \mathbf{x} \in \mathbb{Z}^n \} $$

Важно отметить, что коэффициенты $x_i$ ограничены целыми числами $\mathbb{Z}$, а не действительными числами $\mathbb{R}$. В результате образуется “множество дискретных точек”, подобных равномерно расположенным перекресткам, а не непрерывное пространство с бесконечным множеством точек.

2.2 Геометрический образ

Рассмотрим пример в двумерной плоскости $\mathbb{R}^2$. Если мы выберем в качестве базисных векторов $\mathbf{b}_1 = \begin{pmatrix} 1 \\ 0 \end{pmatrix}$ и $\mathbf{b}_2 = \begin{pmatrix} 0 \\ 1 \end{pmatrix}$, то порожденная ими решетка будет представлять собой множество всех целочисленных координат $(x, y) \in \mathbb{Z}^2$ на координатной плоскости. Это самая простая “квадратная решетка”.

Однако решетки не всегда ортогональны. Например, если мы рассмотрим базис $\mathbf{b}_1 = \begin{pmatrix} 2 \\ 1 \end{pmatrix}$ и $\mathbf{b}_2 = \begin{pmatrix} 1 \\ 3 \end{pmatrix}$, то порожденные точки будут напоминать пересечения диагонально искаженной сетки.

2.3 Неоднозначность базиса и унимодулярные преобразования

Существует важное свойство, касающееся основы безопасности криптографии на решетках: “Существует бесконечное количество базисов, порождающих одну и ту же решетку”.

Например, базис $\mathbf{b}_1 = (1, 0)^T, \mathbf{b}_2 = (0, 1)^T$, упомянутый ранее, порождает решетку $\mathbb{Z}^2$. Базис $\mathbf{b}'_1 = (1, 1)^T, \mathbf{b}'_2 = (2, 3)^T$ порождает абсолютно ту же самую решетку $\mathbb{Z}^2$.

Необходимым и достаточным условием того, что базис $B$ и другой базис $B'$ порождают одну и ту же решетку, является существование матрицы с целочисленными элементами $U \in \mathbb{Z}^{n \times n}$, определитель которой $\det(U) = \pm 1$, так что:

$$ B' = B U $$

Такая матрица $U$ называется “унимодулярной матрицей” (Unimodular matrix).

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

3. Вычислительно сложные задачи на решетках

Безопасность криптографии на решетках зависит от сложности решения определенных математических задач на решетках. Здесь мы представим две самые фундаментальные и известные проблемы.

3.1 Задача поиска кратчайшего вектора (Shortest Vector Problem: SVP)

SVP — это самая классическая и известная задача в теории решеток.

Определение (SVP): Дан произвольный базис решетки $B$. Найдите в решетке $\mathcal{L}(B)$ ненулевой вектор $\mathbf{v}$, евклидова норма (длина) которого минимальна.

Математически это задача поиска вектора $\mathbf{v}$, такого что достигается минимум $\min_{\mathbf{v} \in \mathcal{L}(B) \setminus \{\mathbf{0}\}} \| \mathbf{v} \|$. Эта минимальная длина обозначается как $\lambda_1(\mathcal{L})$ и называется “первым последовательным минимумом решетки”.

В низких измерениях, таких как 2D или 3D, можно нарисовать график и визуально найти самый короткий вектор, или эффективно решить задачу с помощью алгоритма редукции решетки Гаусса. Однако известно, что когда размерность $n$ достигает сотен или тысяч, точное решение SVP является NP-трудным.

В реальной криптографии используется приближенная SVP ($\gamma$-SVP), которая находит “приближенно короткий вектор”, а не строго кратчайший вектор. Когда коэффициент аппроксимации $\gamma$ полиномиального размера, эта проблема все еще считается чрезвычайно сложной.

3.2 Задача поиска ближайшего вектора (Closest Vector Problem: CVP)

CVP также является чрезвычайно важной задачей в криптографии на решетках.

Определение (CVP): Дан произвольный базис решетки $B$ и любой целевой вектор $\mathbf{t} \in \mathbb{R}^m$ в пространстве (не обязательно являющийся точкой решетки). Найдите точку решетки $\mathbf{v} \in \mathcal{L}(B)$, ближайшую к $\mathbf{t}$.

Математически это задача поиска точки решетки $\mathbf{v}$, такой что достигается минимум $\min_{\mathbf{v} \in \mathcal{L}(B)} \| \mathbf{v} - \mathbf{t} \|$.

Как и SVP, CVP является NP-трудной в высоких измерениях. С точки зрения применения в криптографии, проблема LWE, которая будет обсуждаться позже, тесно связана с особым вариантом этой CVP (Bounded Distance Decoding: BDD).

3.3 Почему это не решается в высоких размерностях? (Пределы LLL и BKZ)

Известным алгоритмом для решения задач на решетках высокой размерности является алгоритм LLL (алгоритм Ленстры-Ленстры-Ловаса). Алгоритм LLL работает за полиномиальное время и может в некоторой степени “редуцировать” базис решетки до “хорошего базиса”. Однако кратчайший вектор, который может найти алгоритм LLL, имеет коэффициент аппроксимации, который экспоненциально зависит от размерности ($2^{\mathcal{O}(n)}$) по сравнению с истинным кратчайшим вектором, что недостаточно для нарушения безопасности криптографии.

С помощью более мощных алгоритмов редукции базиса, таких как алгоритм BKZ (Block Korkine-Zolotarev), который является улучшением LLL, можно найти более короткие векторы, но вычислительная сложность возрастает экспоненциально в зависимости от размера блока. В криптографии на решетках безопасные параметры (например, значение размерности $n$) определяются путем оценки времени выполнения этого алгоритма BKZ. В текущих стандартных параметрах PQC размерность $n$ выбирается от 500 до 1000 и более, и считается, что для взлома потребуется время, превышающее возраст Вселенной, даже при использовании суперкомпьютеров или будущих квантовых компьютеров.

4. Математическая формулировка проблемы LWE (Learning With Errors)

Большая часть современной криптографии на решетках основана на проблеме “LWE (Learning With Errors)”, предложенной Одедом Регевом (Oded Regev) в 2005 году. Красота проблемы LWE заключается в простоте ее формулировки и мощном математическом доказательстве “сведения от сложности в худшем случае к сложности в среднем случае”.

4.1 Система линейных уравнений без шума

Чтобы понять проблему LWE, давайте сначала рассмотрим простую систему линейных уравнений без шума. Предположим, у нас есть неизвестный секретный вектор $\mathbf{s} \in \mathbb{Z}_q^n$ (где каждая компонента - целое число от $0$ до $q-1$). Здесь $q$ - простое число.

Мы выбираем случайные векторы коэффициентов $\mathbf{a}_1, \mathbf{a}_2, \dots \in \mathbb{Z}_q^n$ и вычисляем их скалярное произведение с секретным вектором $\mathbf{s}$ по модулю $q$. $b_1 = \langle \mathbf{a}_1, \mathbf{s} \rangle \pmod q$ $b_2 = \langle \mathbf{a}_2, \mathbf{s} \rangle \pmod q$ $\vdots$

Учитывая достаточное количество (не менее $n$) пар $(\mathbf{a}_i, b_i)$, мы можем легко восстановить секретный вектор $\mathbf{s}$, используя “метод исключения Гаусса” из линейной алгебры. Эту задачу легко решить за полиномиальное время.

4.2 Определение проблемы LWE: Добавление шума

Что произойдет, если мы добавим немного “шума (ошибки)” в эту задачу? В этом суть проблемы LWE.

Для неизвестного секретного вектора $\mathbf{s} \in \mathbb{Z}_q^n$, мы добавляем небольшую ошибку $e_i \in \mathbb{Z}_q$ к результату каждого уравнения. $b_i = \langle \mathbf{a}_i, \mathbf{s} \rangle + e_i \pmod q$

Здесь $e_i$ - небольшое целое число со средним значением 0 и относительно небольшим стандартным отклонением (например, выбранное из дискретного распределения Гаусса). Предоставляемая информация представляет собой список пар случайных векторов $\mathbf{a}_i$ и $b_i$, вычисленных с добавлением этой ошибки. $( \mathbf{a}_1, b_1 ), ( \mathbf{a}_2, b_2 ), \dots, ( \mathbf{a}_m, b_m )$

Это можно очень элегантно выразить в матричной форме. Используя случайную матрицу $A \in \mathbb{Z}_q^{m \times n}$, секретный вектор $\mathbf{s} \in \mathbb{Z}_q^n$ и вектор ошибки $\mathbf{e} \in \mathbb{Z}_q^m$, мы можем записать:

$$ \mathbf{b} = A \mathbf{s} + \mathbf{e} \pmod q $$

Нам даны только $A$ и $\mathbf{b}$. Процесс поиска $\mathbf{s}$ на их основе называется “проблемой поиска LWE” (Search LWE problem).

Поскольку в ней присутствует ошибка $e_i$, попытка использовать метод исключения Гаусса приведет к экспоненциальному росту ошибки в процессе сложения и вычитания уравнений, делая невозможным получение правильного ответа. На первый взгляд это выглядит как простая система линейных уравнений, но добавление этого небольшого шума повышает уровень сложности задачи до NP-трудной.

4.3 Проблема решения LWE (Decision LWE)

В криптографических доказательствах часто используется вариация задачи поиска LWE, называемая “проблемой решения LWE” (Decision LWE problem).

Задача решения LWE состоит в том, чтобы, получив список образцов из следующих двух распределений, определить, из какого распределения они получены:

Распределение LWE: Намеренно вычисленное $(A, \mathbf{b} = A\mathbf{s} + \mathbf{e} \pmod q)$
Равномерное случайное распределение: $(A, \mathbf{u})$, состоящее из совершенно случайно выбранной матрицы $A$ и вектора $\mathbf{u}$

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

4.4 Сведение от сложности в худшем случае к сложности в среднем случае (Теорема Регева)

Величайшим достижением Одеда Регева было математическое связывание сложности этой проблемы LWE со сложностью вышеупомянутых задач на решетках (SVP и CVP).

Используя квантовое сведение (Quantum reduction), он доказал, что: “Если существует алгоритм полиномиального времени, который может решить проблему LWE в среднем (для случайно выбранных $A$ и $\mathbf{e}$), то существует квантовый алгоритм полиномиального времени, который может решить Gap-SVP в худшем случае (самый сложный случай) для любой решетки”. (Позже Пейкерт (Peikert) и другие также продемонстрировали классическое сведение).

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

graph TD A["Худший случай задач на решетках (Gap-SVP, SIVP)"] -->|Квантовое/Классическое сведение| B["Проблема LWE в среднем случае"] B -->|Криптографическая конструкция| C["Криптосистемы на основе LWE (PKE, KEM, FHE)"] style A fill:#ffcccc,stroke:#ff0000,stroke-width:2px,color:#000 style B fill:#ccffcc,stroke:#00aa00,stroke-width:2px,color:#000 style C fill:#ccccff,stroke:#0000ff,stroke-width:2px,color:#000

5. Построение криптографии с открытым ключом с использованием LWE (Криптосистема Регева)

Поняв сложность проблемы LWE, давайте посмотрим на базовую криптосистему с открытым ключом, предложенную Одедом Регевом, чтобы увидеть, как с ее помощью выполняются шифрование и дешифрование. Здесь мы объясним самый основной механизм шифрования 1-битного сообщения $M \in \{0, 1\}$.

5.1 Генерация ключей (Key Generation)

Определяются системные параметры: простое число $q$, размерность $n$ и количество уравнений $m$ ($m > n \log q$).
В качестве секретного ключа случайно выбирается вектор $\mathbf{s} \in \mathbb{Z}_q^n$.
Генерируется случайная матрица $A \in \mathbb{Z}_q^{m \times n}$.
Малый вектор ошибки $\mathbf{e} \in \mathbb{Z}_q^m$ выбирается из распределения ошибок, например, дискретного гауссовского.
Вычисляется вектор $\mathbf{b} = A \mathbf{s} + \mathbf{e} \pmod q$.
Открытый ключ (Public Key) — это $(A, \mathbf{b})$.
Секретный ключ (Secret Key) — это $\mathbf{s}$.

Открытый ключ - это буквально “экземпляр проблемы LWE”. Поиск секретного ключа $\mathbf{s}$ по открытому ключу $(A, \mathbf{b})$ эквивалентен решению задачи поиска LWE, поэтому безопасность гарантирована.

5.2 Шифрование (Encryption)

Алиса использует открытый ключ Боба $(A, \mathbf{b})$ для шифрования 1-битного сообщения $M \in \{0, 1\}$.

Выбирается случайный бинарный вектор (с компонентами 0 или 1) $\mathbf{r} \in \{0, 1\}^m$.
В качестве первой части шифротекста вычисляется вектор $\mathbf{u} = A^T \mathbf{r} \pmod q$. ($A^T$ - транспонированная матрица $A$. Это означает, что мы суммируем те строки $A$, для которых компоненты $\mathbf{r}$ равны 1).
В качестве второй части шифротекста вычисляется скаляр $v = \mathbf{b}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor \pmod q$. (Если сообщение $M$ равно 0, ничего не добавляется; если $1$, добавляется ровно половина значения $q$, то есть $\lfloor \frac{q}{2} \rfloor$).
Шифротекст (Ciphertext) представляет собой $(\mathbf{u}, v)$.

Интуитивный смысл шифрования заключается во взятии “суммы случайного подмножества” для матрицы открытого ключа $A$ и вектора $\mathbf{b}$. Из-за сложности проблемы решения LWE этот шифротекст $(\mathbf{u}, v)$ выглядит неотличимым от полностью случайного вектора и равномерного случайного числа (семантическая безопасность: Semantic Security).

flowchart LR M["Сообщение M в {0,1}"] --> Enc PK["Открытый ключ (A, b)"] --> Enc r["Случайный бинарный вектор r"] --> Enc subgraph Enc ["Процесс шифрования"] direction TB u_calc["u = A^T * r mod q"] v_calc["v = b^T * r + M * floor(q/2) mod q"] end Enc --> CT["Шифротекст (u, v)"]

5.3 Дешифрование (Decryption)

Боб расшифровывает шифротекст $(\mathbf{u}, v)$, используя свой секретный ключ $\mathbf{s}$.

Он вычисляет следующее значение: $D = v - \mathbf{s}^T \mathbf{u} \pmod q$
Если вычисленный результат ближе к $0$, выводится $M=0$; если он ближе к $\lfloor \frac{q}{2} \rfloor$, выводится $M=1$.

Давайте математически раскроем это, чтобы понять, почему оно может быть расшифровано. Вспомните, что $\mathbf{b} = A \mathbf{s} + \mathbf{e}$.

$$ \begin{aligned} v - \mathbf{s}^T \mathbf{u} &= (\mathbf{b}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor) - \mathbf{s}^T (A^T \mathbf{r}) \\ &= ((A \mathbf{s} + \mathbf{e})^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor) - \mathbf{s}^T A^T \mathbf{r} \\ &= (\mathbf{s}^T A^T \mathbf{r} + \mathbf{e}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor) - \mathbf{s}^T A^T \mathbf{r} \\ &= \mathbf{e}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor \pmod q \end{aligned} $$

Здесь $\mathbf{s}^T A^T \mathbf{r}$ аккуратно компенсируется и исчезает из уравнения! Остается только $\mathbf{e}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor$.

$\mathbf{e}$ - это вектор шума с очень маленькими компонентами, а $\mathbf{r}$ - бинарный вектор с компонентами 0 или 1. Следовательно, их скалярное произведение $\mathbf{e}^T \mathbf{r}$ также останется относительно небольшим значением (если параметры выбраны правильно).

Если $M=0$, то результат будет равен $\mathbf{e}^T \mathbf{r}$, что является малым значением, близким к $0$.
Если $M=1$, то результат будет равен $\mathbf{e}^T \mathbf{r} + \lfloor \frac{q}{2} \rfloor$, что будет расположено вокруг половины значения $q$, то есть $\lfloor \frac{q}{2} \rfloor$.

Если параметры спроектированы так, что абсолютное значение ошибки $\mathbf{e}^T \mathbf{r}$ находится в пределах $\frac{q}{4}$, Боб может точно определить (расшифровать) сообщение $M$, просто посмотрев, к чему ближе результат вычислений: к $0$ или к $\lfloor \frac{q}{2} \rfloor$. Это прекрасный механизм, благодаря которому работает криптография на базе LWE.

flowchart LR CT["Шифротекст (u, v)"] --> Dec SK["Секретный ключ s"] --> Dec subgraph Dec ["Процесс дешифрования"] direction TB calc["Вычислить D = v - s^T * u mod q"] check["Проверить, ближе ли D к 0 или q/2"] end calc --> check Dec --> M_out["Восстановленное сообщение M"]

6. Игрушечный пример LWE-шифрования с конкретными числами

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

[Установка параметров]

Модуль $q = 17$ (Простое число. Таким образом, значения принимаются в диапазоне от $0$ до $16$)
Размерность $n = 2$
Количество уравнений $m = 4$
Предположим, мы шифруем сообщение $M = 1$.
Величина сдвига сообщения: $\lfloor \frac{q}{2} \rfloor = \lfloor \frac{17}{2} \rfloor = 8$

[1. Фаза генерации ключей] Боб случайным образом выбирает секретный ключ $\mathbf{s}$, матрицу $A$ и вектор ошибки $\mathbf{e}$.

$$ \mathbf{s} = \begin{pmatrix} 3 \\ 4 \end{pmatrix} \in \mathbb{Z}_{17}^2 $$ $$ A = \begin{pmatrix} 2 & 15 \\ 1 & 8 \\ 14 & 5 \\ 9 & 10 \end{pmatrix} \in \mathbb{Z}_{17}^{4 \times 2} $$ $$ \mathbf{e} = \begin{pmatrix} 1 \\ -1 \\ 0 \\ 2 \end{pmatrix} \equiv \begin{pmatrix} 1 \\ 16 \\ 0 \\ 2 \end{pmatrix} \pmod{17} $$

Далее вычисляется открытый ключ $\mathbf{b}$.

$$ A \mathbf{s} = \begin{pmatrix} 2 & 15 \\ 1 & 8 \\ 14 & 5 \\ 9 & 10 \end{pmatrix} \begin{pmatrix} 3 \\ 4 \end{pmatrix} = \begin{pmatrix} 2\times 3 + 15\times 4 \\ 1\times 3 + 8\times 4 \\ 14\times 3 + 5\times 4 \\ 9\times 3 + 10\times 4 \end{pmatrix} = \begin{pmatrix} 6 + 60 \\ 3 + 32 \\ 42 + 20 \\ 27 + 40 \end{pmatrix} = \begin{pmatrix} 66 \\ 35 \\ 62 \\ 67 \end{pmatrix} $$

Мы вычисляем это по модулю 17. (Например, $66 = 17 \times 3 + 15$)

$$ A \mathbf{s} \pmod{17} = \begin{pmatrix} 15 \\ 1 \\ 11 \\ 16 \end{pmatrix} $$

Мы прибавляем вектор ошибки $\mathbf{e}$.

$$ \mathbf{b} = A \mathbf{s} + \mathbf{e} = \begin{pmatrix} 15 \\ 1 \\ 11 \\ 16 \end{pmatrix} + \begin{pmatrix} 1 \\ 16 \\ 0 \\ 2 \end{pmatrix} = \begin{pmatrix} 16 \\ 17 \\ 11 \\ 18 \end{pmatrix} \equiv \begin{pmatrix} 16 \\ 0 \\ 11 \\ 1 \end{pmatrix} \pmod{17} $$

Открытый ключ состоит из $A$ и $\mathbf{b} = (16, 0, 11, 1)^T$.

[2. Фаза шифрования] Алиса шифрует сообщение $M = 1$. Она выбирает случайный вектор $\mathbf{r}$. Пусть $\mathbf{r} = (1, 0, 1, 0)^T$.

Вычисляется $\mathbf{u}$.

$$ \mathbf{u} = A^T \mathbf{r} = \begin{pmatrix} 2 & 1 & 14 & 9 \\ 15 & 8 & 5 & 10 \end{pmatrix} \begin{pmatrix} 1 \\ 0 \\ 1 \\ 0 \end{pmatrix} = \begin{pmatrix} 2 \times 1 + 14 \times 1 \\ 15 \times 1 + 5 \times 1 \end{pmatrix} = \begin{pmatrix} 16 \\ 20 \end{pmatrix} \equiv \begin{pmatrix} 16 \\ 3 \end{pmatrix} \pmod{17} $$

Вычисляется $v$.

$$ \mathbf{b}^T \mathbf{r} = (16, 0, 11, 1) \begin{pmatrix} 1 \\ 0 \\ 1 \\ 0 \end{pmatrix} = 16 \times 1 + 11 \times 1 = 27 \equiv 10 \pmod{17} $$

Прибавляется значение, соответствующее сообщению $M=1$: $\lfloor 17/2 \rfloor = 8$.

$$ v = \mathbf{b}^T \mathbf{r} + M \cdot 8 = 10 + 1 \times 8 = 18 \equiv 1 \pmod{17} $$

Алиса отправляет Бобу шифротекст $(\mathbf{u}, v) = \left( \begin{pmatrix} 16 \\ 3 \end{pmatrix}, 1 \right)$.

[3. Фаза дешифрования] Боб, получивший шифротекст, расшифровывает его с помощью секретного ключа $\mathbf{s} = (3, 4)^T$. Он вычисляет формулу процесса дешифрования: $D = v - \mathbf{s}^T \mathbf{u} \pmod{17}$.

$$ \mathbf{s}^T \mathbf{u} = (3, 4) \begin{pmatrix} 16 \\ 3 \end{pmatrix} = 3 \times 16 + 4 \times 3 = 48 + 12 = 60 \equiv 9 \pmod{17} $$ $$ D = v - \mathbf{s}^T \mathbf{u} = 1 - 9 = -8 \pmod{17} $$

Здесь, в мире по модулю 17, $-8$ равно $9$ ($-8 + 17 = 9$). Полученное значение $D = 9$ проверяется, к чему оно ближе: к $0$ или к $8$ ($\lfloor 17/2 \rfloor$). Поскольку $9$ явно ближе к $8$, чем к $0$, Боб смог правильно восстановить $M = 1$!

Почему получилось $9$? Давайте вспомним доказательство, приведенное ранее. Часть ошибки равна $\mathbf{e}^T \mathbf{r} = (1, -1, 0, 2) (1, 0, 1, 0)^T = 1 \times 1 + 0 \times 1 = 1$. Следовательно, результат вычислений равен $\mathbf{e}^T \mathbf{r} + M \cdot 8 = 1 + 8 = 9$, и мы убедились, что теоретическое значение было вычислено правильно.

7. Эволюция к практическому применению: Ring-LWE и Module-LWE

Стандартная проблема LWE (Standard LWE), которую мы объясняли до сих пор, имеет очень сильное доказательство безопасности, но на практике у нее есть фатальные недостатки: “огромный размер ключа” и “высокая вычислительная стоимость”.

В Standard LWE открытый ключ включает огромную матрицу $A \in \mathbb{Z}_q^{m \times n}$. Когда параметр $n$ достигает сотен или тысяч, размер этой матрицы достигает нескольких мегабайт, что слишком тяжело для передачи и приема каждый раз в интернет-протоколах связи (таких как TLS). Кроме того, умножение матрицы на вектор требует сложности вычислений $\mathcal{O}(n^2)$.

Для решения этой проблемы были внедрены “Ring-LWE (RLWE)” и “Module-LWE (MLWE)”, которые включают алгебраическую структуру, называемую кольцами многочленов (Polynomial rings), в решетку.

7.1 Интуиция Ring-LWE

В Ring-LWE векторы и матрицы заменяются на элементы (многочлены) над кольцом многочленов $\mathcal{R}_q = \mathbb{Z}_q[X]/(X^n + 1)$. (Здесь $n$ выбирается как степень двойки).

В то время как открытым ключом в Standard LWE была матрица $A$, Ring-LWE использует один многочлен $a(x)$. Секретный ключ $s(x)$ и ошибка $e(x)$ также становятся многочленами. Уравнение выглядит следующим образом:

$$ b(x) = a(x) \cdot s(x) + e(x) \pmod q $$

Поскольку это умножение многочленов, за счет использования “теоретико-числового преобразования (Number Theoretic Transform: NTT)”, аналогичного быстрому преобразованию Фурье (FFT), вычислительная сложность может быть резко снижена до $\mathcal{O}(n \log n)$. Кроме того, поскольку размер открытого ключа уменьшается с матрицы до одного многочлена, размер данных сокращается до $\mathcal{O}(n)$. Это дает подавляющее преимущество в пропускной способности связи.

С математической точки зрения Ring-LWE сводится к задаче на решетке с особой симметрией, называемой “идеальной решеткой” (Ideal Lattice), а не на общей решетке.

7.2 Module-LWE и стандартизация NIST (Kyber / ML-KEM)

Хотя Ring-LWE эффективен, существовало некоторое опасение, что специальная алгебраическая структура идеальных решеток может стать отправной точкой для будущих атак. Поэтому “Module-LWE (MLWE)” был создан, чтобы взять “лучшее из обоих миров”: консервативную безопасность Standard LWE и эффективность Ring-LWE.

В Module-LWE мы рассматриваем небольшие матрицы и векторы, элементами которых являются многочлены. Другими словами, мы работаем с модулями над кольцом. В настоящее время “CRYSTALS-Kyber” (название стандарта: ML-KEM), выбранный NIST в качестве стандарта алгоритма инкапсуляции ключей (KEM) для PQC, построен именно на сложности этой проблемы Module-LWE.

8. Почему это безопасно против квантовых компьютеров?

Наконец, мы коснемся сути вопроса: “Почему считается, что криптография на решетках не может быть взломана даже с помощью квантовых компьютеров?”

Алгоритм Шора, с помощью которого квантовые компьютеры взламывают шифрование RSA и криптографию на эллиптических кривых, по сути, является алгоритмом для решения “проблемы скрытой подгруппы (Hidden Subgroup Problem: HSP)”. Математическая структура (конечные абелевы группы), лежащая в основе RSA и ECC, обладает периодичностью, и эта периодичность (скрытая подгруппа) может быть извлечена за один шаг путем использования специальной операции квантового алгоритма, называемой квантовым преобразованием Фурье (QFT).

Однако задачи на решетках в корне отличаются. Решетки также имеют периодичность, но то, что ищется в SVP и CVP, — это геометрические нелинейные свойства, такие как “кратчайшее расстояние” и “удаление шума”. Даже если применить “квантовое преобразование Фурье на абелевой группе”, подобно алгоритму Шора, непосредственно к задачам на решетках, полезную информацию для их решения нельзя эффективно извлечь. На сегодняшний день не было найдено квантовых алгоритмов, способных решить SVP или LWE за полиномиальное время. Широко распространено мнение, что даже с мощью параллельных вычислений квантовых компьютеров единственным эффективным средством является поиск, близкий к полному перебору (ускорение в виде квадратного корня с помощью алгоритма Гровера).

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

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

Решетка (Lattice) — это дискретное пространство, представленное линейными комбинациями базисных векторов с целыми коэффициентами, и в высоких измерениях становится трудно найти “хороший базис”, близкий к ортогональному (SVP).
Проблема LWE (Learning With Errors) — это проблема решения систем линейных уравнений с шумом. Поскольку она связана со сложностью задач на решетках в худшем случае, это обеспечивает сильное доказательство безопасности.
Используя проблему LWE, шифрование и дешифрование (Криптосистема Регева) реализуются с помощью хитроумного механизма намеренного добавления или удаления шума.
В реальных протоколах для повышения эффективности связи и скорости вычислений используются Ring-LWE и Module-LWE с кольцами многочленов, которые служат основой для стандарта NIST ML-KEM.

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

Гипотеза Римана и распределение простых чисел: глубокая связь с современной криптографией

Fri, 11 Sep 2026 16:00:00 +0900

1. Введение: Тайна простых чисел во Вселенной и гипотеза Римана

«Простые числа» (Prime Numbers) — это натуральные числа, которые делятся только на 1 и на сами себя. В мире математики их часто называют «атомами». Эта последовательность, 2, 3, 5, 7, 11, 13…, на первый взгляд кажется хаотичной и случайной. С тех пор как древнегреческий математик Евклид доказал, что «простых чисел бесконечно много», бесчисленное множество математиков пытались разгадать закономерности, скрывающиеся в этом ряду.

Ближе всего к разгадке тайны простых чисел подошла «Гипотеза Римана» (Riemann Hypothesis), предложенная немецким математиком Бернхардом Риманом в 1859 году. Гипотеза Римана является одной из самых важных и нерешенных проблем в современной математике. Она также включена в список Задач тысячелетия Института Клэя, за решение которой назначена награда в 1 миллион долларов.

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

В этой статье мы совершим математическое путешествие: от распределения простых чисел к теореме о распределении простых чисел, дзета-функции Римана и, наконец, к сути гипотезы Римана. Мы чрезвычайно подробно и глубоко рассмотрим, как всё это связано с современными криптографическими технологиями, и что произойдет с миром, если гипотеза Римана будет доказана.

2. Теорема о распределении простых чисел: Открытие Гаусса

Чтобы понять, как распределены простые числа, математики придумали функцию распределения простых чисел (Prime-counting function) $\pi(x)$, которая показывает «сколько простых чисел существует до заданного числа $x$».

Например:

$\pi(10) = 4$ (2, 3, 5, 7)
$\pi(100) = 25$
$\pi(1000) = 168$

15-летний гениальный математик Карл Фридрих Гаусс, вычислив огромные таблицы простых чисел, обнаружил, что частота появления простых чисел убывает обратно пропорционально натуральному логарифму $\ln x$. Иными словами, он предположил, что вероятность найти простое число в окрестности числа $x$ составляет примерно $\frac{1}{\ln x}$.

Выражение этой идеи с помощью интеграла называется интегральным логарифмом (Logarithmic integral) $\text{Li}(x)$:

$$ \text{Li}(x) = \int_{2}^{x} \frac{dt}{\ln t} $$

Предположение Гаусса было независимо доказано в 1896 году Жаком Адамаром и Шарлем Жан де ла Валле-Пуссеном, и утвердилось как Теорема о распределении простых чисел (Prime Number Theorem, PNT).

$$ \lim_{x \to \infty} \frac{\pi(x)}{\text{Li}(x)} = 1 $$

Или же это можно приблизительно выразить следующим образом:

$$ \pi(x) \sim \frac{x}{\ln x} $$

Эта теорема показала, что на макроскопическом уровне простые числа распределены очень плавно и предсказуемо. Однако на микроскопическом уровне между $\pi(x)$ и $\text{Li}(x)$ всегда существует «погрешность», то есть «флуктуация». Именно природа этой флуктуации является величайшей загадкой, которую пытается разгадать гипотеза Римана.

3. Дзета-функция Римана и произведение Эйлера

Самым мощным оружием в анализе распределения простых чисел является дзета-функция Римана (Riemann Zeta Function). Изначально это был бесконечный ряд, определенный Леонардом Эйлером для вещественных чисел $s > 1$.

$$ \zeta(s) = \sum_{n=1}^\infty \frac{1}{n^s} = 1 + \frac{1}{2^s} + \frac{1}{3^s} + \frac{1}{4^s} + \dots $$

Одно из величайших достижений Эйлера заключалось в том, что он доказал, что этот бесконечный ряд можно представить как бесконечное произведение по всем простым числам $p$. Это и есть Тождество Эйлера (Euler Product Formula).

$$ \zeta(s) = \prod_{p \text{ prime}} \frac{1}{1 - p^{-s}} = \left( \frac{1}{1 - 2^{-s}} \right) \left( \frac{1}{1 - 3^{-s}} \right) \left( \frac{1}{1 - 5^{-s}} \right) \dots $$

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

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

4. Аналитическое продолжение и расширение на комплексную плоскость

Гениальность Римана заключалась в том, что он расширил переменную $s$ в функции $\zeta(s)$, которую Эйлер рассматривал только для вещественных чисел, до комплексного числа $s = \sigma + it$ (где $\sigma$ — действительная часть, а $t$ — мнимая часть).

Исходный бесконечный ряд сходится только при $\sigma > 1$, но Риман, используя метод «аналитического продолжения» (Analytic Continuation), расширил определение функции так, чтобы $\zeta(s)$ имела смысл на всей комплексной плоскости, за исключением полюса в точке $s = 1$.

Далее он вывел красивое функциональное уравнение (Functional equation), которому удовлетворяет дзета-функция.

$$ \zeta(s) = 2^s \pi^{s-1} \sin\left(\frac{\pi s}{2}\right) \Gamma(1-s) \zeta(1-s) $$

Здесь $\Gamma(x)$ — гамма-функция. Это уравнение позволяет узнать свойства функции в левой полуплоскости на основе её свойств в правой полуплоскости.

Нули (Zeros of the Zeta Function)

Комплексные числа $s$, при которых значение дзета-функции становится равным 0, называются «нулями». Из функционального уравнения следует, что когда $s$ — отрицательное четное число ($-2, -4, -6, \dots$), значение $\sin(\pi s / 2)$ равно 0, поэтому $\zeta(s) = 0$. Они называются тривиальными нулями (Trivial zeros).

Однако для распределения простых чисел важны другие нули — те, что находятся в «критической полосе» (Critical strip) $0 \le \sigma \le 1$, так называемые нетривиальные нули (Non-trivial zeros).

5. Суть гипотезы Римана и явная формула

Риман вычислил несколько таких нулей и выдвинул одно поразительное предположение. Это и есть гипотеза Римана.

Гипотеза Римана (Riemann Hypothesis) Все нетривиальные нули дзета-функции Римана $\zeta(s)$ лежат на прямой, действительная часть которой равна $1/2$ ($\text{Re}(s) = 1/2$).

Эта прямая с действительной частью 1/2 называется «критической прямой» (Critical line).

graph TD A["Дзета-функция Римана ζ(s)"] --> B["Расширение на комплексную плоскость аналитическим продолжением"] B --> C["Тривиальные нули (s = -2, -4, -6 ...)"] B --> D["Нетривиальные нули (0 <= Re(s) <= 1)"] D --> E["Гипотеза Римана"] E --> F["Все нетривиальные нули лежат на Re(s) = 1/2"] F --> G["К доказательству предела погрешности распределения простых чисел"]

Почему гипотеза Римана так важна? Потому что нули дзета-функции полностью определяют распределение простых чисел.

Риман и более поздний математик фон Мангольдт вывели «явную формулу» (Explicit formula), которая точно описывает распределение простых чисел. Используя функцию Чебышёва $\psi(x)$, это можно выразить следующим образом:

$$ \psi(x) = x - \sum_{\rho} \frac{x^\rho}{\rho} - \ln(2\pi) - \frac{1}{2}\ln(1 - x^{-2}) $$

Здесь сумма берется по всем нетривиальным нулям $\rho$ дзета-функции. Главным членом является $x$ (что соответствует теореме о распределении простых чисел), а путем прибавления и вычитания волнообразных членов, зависящих от нулей $\rho$, восстанавливается точное ступенчатое распределение простых чисел. Можно сказать, что нетривиальные нули представляют собой «частоты (волны)» распределения простых чисел.

Если гипотеза Римана верна, и действительная часть всех нетривиальных нулей $\rho$ в точности равна $1/2$, то член погрешности в теореме о распределении простых чисел будет укладываться в минимально возможный теоретический диапазон.

$$ |\pi(x) - \text{Li}(x)| \le \frac{1}{8\pi} \sqrt{x} \ln x \quad \text{for} \quad x \ge 2657 $$

Другими словами, если гипотеза Римана истинна, это докажет, что простые числа распределены настолько «правильно и красиво», насколько мы только можем себе представить.

6. Неразрывная связь современных криптографических технологий и простых чисел

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

Безопасность любых коммуникаций, будь то оплата кредитной картой в интернете, передача паролей или электронные подписи в блокчейне, зависит от «простых чисел».

Как работает шифрование RSA

Безопасность RSA основана на математическом факте (задаче факторизации), что «очень сложно разложить большое составное число на простые множители».

Генерация ключей: Случайным образом выбираются два огромных простых числа $p$ и $q$ (например, по 2048 бит каждое). Они перемножаются для получения $N = p \times q$. Это $N$ становится частью открытого ключа. Используя функцию Эйлера $\phi(N) = (p-1)(q-1)$, генерируется закрытый ключ $d$.
$$ e \times d \equiv 1 \pmod{\phi(N)} $$
Шифрование и расшифрование: Открытый текст $M$ преобразуется в зашифрованный текст $C$ с использованием открытого ключа $e, N$.
$$ C \equiv M^e \pmod{N} $$
Расшифровать текст может только тот, кто обладает закрытым ключом $d$.
$$ M \equiv C^d \pmod{N} $$

graph LR A["Открытый текст (Plaintext)"] --> B["Шифрование открытым ключом (e, N)"] B --> C["Зашифрованный текст (Ciphertext)"] C --> D["Расшифрование закрытым ключом (d)"] D --> E["Исходный открытый текст"] F["Злоумышленник (Attacker)"] -- "Попытка факторизации N" --> C F -.-> G["Без знания p и q вычислить d невозможно"]

Чтобы взломать шифр RSA, нужно найти (факторизовать) исходные простые числа $p$ и $q$ из гигантского числа $N$. Считается, что даже с использованием самых передовых на сегодня алгоритмов (таких как общий метод решета числового поля, GNFS) и суперкомпьютеров, разложение числа из сотен цифр займет время, намного превышающее возраст Вселенной.

7. Влияние гипотезы Римана на криптографические технологии

Так как же пересекаются «гипотеза Римана», находящаяся на вершине чистой математики, и «криптография»?

7.1. Алгоритмы генерации простых чисел (проверка на простоту) и Обобщенная гипотеза Римана (GRH)

Для работы шифрования RSA необходимо сначала сгенерировать огромные простые числа $p$ и $q$. Однако надежно и быстро определить, «является ли число простым», не так-то просто.

В настоящее время на практике применяется вероятностный алгоритм — тест простоты Миллера-Рабина (Miller-Rabin primality test). Этот алгоритм быстр, но существует крайне низкая вероятность того, что составное число будет ошибочно признано простым (так называемые «псевдопростые числа»).

Однако, если предположить, что «Обобщенная гипотеза Римана» (Generalized Riemann Hypothesis, GRH), которая распространяет гипотезу Римана на L-функции Дирихле, верна, то ситуация кардинально меняется. Если GRH истинна, математически гарантируется верхняя граница количества проверок в тесте Миллера-Рабина, и вероятностный алгоритм превращается в «детерминированный алгоритм полиномиального времени» (этот важный факт был известен еще до открытия теста простоты AKS).

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

7.2. Связь с алгоритмами факторизации

Знания о распределении простых чисел также необходимы при оценке вычислительной сложности алгоритмов взлома шифров (таких как общий метод решета числового поля). Многие алгоритмы факторизации опираются на распределение «гладких чисел» (Smooth numbers — чисел, имеющих только небольшие простые множители).

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

8. Если гипотеза Римана будет доказана, будут ли взломаны шифры?

В качестве городской легенды иногда можно услышать, что «если гипотеза Римана будет решена, шифрование RSA рухнет в одно мгновение», но математически это неверно.

Само доказательство гипотезы Римана не приведет к мгновенному появлению магического алгоритма, который радикально ускорит факторизацию. Гипотеза Римана — это теорема о макроскопической «закономерности распределения» простых чисел, она не сообщает напрямую о том, на какие именно простые числа делится конкретное число $N$ (локальные свойства).

Однако влияние не будет нулевым. В процессе доказательства гипотезы Римана с огромной вероятностью могут быть открыты «новые математические инструменты» и «неизвестные аналитические методы». Как показывает история, доказательство Великой теоремы Ферма или гипотезы Пуанкаре породило новые теории, которые привели к колоссальному скачку в математике в целом.

Если будут разработаны неизвестные ранее методы алгебраической геометрии или некоммутативной геометрии, позволяющие полностью манипулировать свойствами нулей дзета-функции Римана, нельзя исключать, что это в конечном итоге приведет к открытию революционного алгоритма факторизации (например, классического алгоритма, который снизит время вычислений до полиномиального). В этом смысле криптографы никогда не смогут отвести взгляд от того, что происходит вокруг гипотезы Римана.

Квантовые компьютеры и алгоритм Шора

Куда более прямой и реальной угрозой для криптографических технологий является не доказательство гипотезы Римана, а квантовые компьютеры. Опубликованный Питером Шором (Peter Shor) в 1994 году «алгоритм Шора» доказал, что при наличии достаточно мощного квантового компьютера факторизация может быть решена за полиномиальное время. Это фундаментально разрушит шифрование RSA и криптографию на эллиптических кривых.

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

9. Заключение: Перекресток математической абстракции и реального мира

graph TD A["Исследования в чистой математике"] --> B["Разгадка гипотезы Римана"] B --> C["Полное понимание распределения простых чисел"] C --> D["Стремительное развитие теории чисел и алгебраической геометрии"] D -.-> E["Вероятность появления новых алгоритмов факторизации"] E -.-> F["Обновление оценки безопасности криптографических технологий"] A --> G["Прикладная математика и информатика"] G --> H["Оптимизация проверки на простоту и генерации шифров"] H --> F

Неустанные поиски простых чисел, ведущиеся со времен Древней Греции, благодаря гению Римана превратились в прекрасную симфонию на комплексной плоскости (нули дзета-функции). И поразительно, что этот кристалл чистейшей математики спустя столетия применяется как самый мощный щит, гарантирующий безопасность интернет-общества.

Гипотеза Римана символизирует одновременно «абстрактную красоту» математики и её «удивительную применимость в физическом мире и реальном обществе».

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

【Математическое объяснение】Как работает алгоритм RSA, объяснено для старшеклассников

Fri, 11 Sep 2026 13:00:00 +0900

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

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

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

1. Симметричное и асимметричное шифрование (с открытым ключом)

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

1.1 Ограничения симметричного шифрования

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

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

У этого метода есть серьезная проблема: “проблема распределения ключей”. Если находящиеся далеко друг от друга Алиса и Боб связываются впервые, как им безопасно обменяться ключами, чтобы их никто не перехватил? Если ключ украдет третье лицо во время пересылки, все последующие зашифрованные сообщения станут достоянием гласности.

1.2 Революционное изобретение: “Шифрование с открытым ключом”

Для решения этой проблемы с распределением ключей была изобретена “система шифрования с открытым ключом”. Алгоритм RSA относится к этому типу.

В системе с открытым ключом используются два разных ключа: “ключ для шифрования (открытый ключ)” и “ключ для расшифрования (закрытый ключ)”.

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

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

graph TD A["Алиса (отправитель)"] --> B["Открытый текст (сообщение)"] B --> C["Процесс шифрования"] D["Открытый ключ Боба (доступен всем)"] --> C C --> E["Отправка через интернет: Зашифрованный текст"] E --> F["Процесс расшифрования"] G["Закрытый ключ Боба (только у Боба)"] --> F F --> H["Восстановленный открытый текст (сообщение)"] H --> I["Боб (получатель)"]

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

2. Математические основы RSA 1: Простые числа и факторизация

Безопасность алгоритма RSA основана на математическом факте: “факторизация (разложение на простые множители) огромных чисел — чрезвычайно сложная задача”.

2.1 Что такое простые числа?

Простое число — это “натуральное число больше 1, которое делится без остатка только на 1 и на само себя”. Пример: $2, 3, 5, 7, 11, 13, 17, 19, 23...$

Простые числа — это словно “атомы” всех целых чисел. Любое натуральное число можно разложить в виде произведения простых чисел. Это называется факторизацией (разложением на простые множители). Например, $60 = 2^2 \times 3 \times 5$. Тот факт, что любое число можно разложить на простые множители единственным образом (если не учитывать порядок), известен как “основная теорема арифметики”.

2.2 Сложность факторизации (Односторонняя функция)

Здесь важна асимметрия: “умножать легко, а раскладывать на множители — сложно”.

Например, попробуйте вычислить в уме произведение следующих двух простых чисел: $11 \times 13 = ?$ Это просто. Ответ $143$.

А как насчет следующего числа? Разложите на простые множители $323$. Ну как? Это должно занять некоторое время. (Ответ $17 \times 19$).

Если числа небольшие, человек еще может как-то справиться, но по мере увеличения чисел вычисления становятся взрывообразно сложными даже для компьютеров. В распространенном сегодня алгоритме RSA используется число $N = p \times q$, полученное путем перемножения двух невероятно огромных простых чисел $p$ и $q$ размером 2048 бит (около 600 цифр в десятичной системе).

Когда даны два огромных простых числа $p$ и $q$, вычисление $N$ занимает у компьютера долю секунды (меньше миллисекунды). Однако, если дано только $N$, поиск исходных $p$ и $q$ займет столько времени, что даже самые быстрые суперкомпьютеры современности не смогут решить эту задачу и за триллионы лет.

Эта “вычислительная асимметрия (в одну сторону легко, в обратную — сложно)” является фундаментом для создания связи между открытым и закрытым ключами.

3. Математические основы RSA 2: Сравнения (Арифметика остатков / модульная арифметика)

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

3.1 Математика часов

Модульную арифметику часто сравнивают с “математикой часов”. Предположим, сейчас 10 часов. Который час будет через 5 часов? $10 + 5 = 15$ часов, но на обычных 12-часовых часах мы ответим “3 часа”. Это потому, что остаток от деления 15 на 12 равен 3.

В математике это записывается следующим образом:

$$ 15 \equiv 3 \pmod{12} $$

Это читается как “15 сравнимо с 3 по модулю 12 (остатки от деления на 12 равны)”.

3.2 Основные свойства сравнений

Сравнения обладают очень удобными свойствами, похожими на свойства обычных уравнений ($=$). Пусть модуль (делитель) равен $N$. Если $a \equiv b \pmod N$ и $c \equiv d \pmod N$, то выполняется следующее:

Сложение: $a + c \equiv b + d \pmod N$
Вычитание: $a - c \equiv b - d \pmod N$
Умножение: $a \times c \equiv b \times d \pmod N$
Возведение в степень: $a^k \equiv b^k \pmod N$ (где $k$ — натуральное число)

Особенно важным является свойство “возведения в степень”. Оно означает, что “остаток от степени равен степени от остатка”. Например, мы хотим найти остаток от деления $7^{100}$ на $5$. Честно умножать $7$ само на себя 100 раз, а затем делить на $5$ было бы очень сложно. Но используя свойства сравнений, поскольку $7 \equiv 2 \pmod 5$, мы получаем $7^{100} \equiv 2^{100} \pmod 5$, что позволяет кардинально упростить вычисления. В мире криптографии мы работаем с возведением в степень очень больших чисел, поэтому это свойство просто необходимо.

4. Математические основы RSA 3: Функция Эйлера и теорема Эйлера

Здесь начинается магическая математика, составляющая ядро RSA. Появляется “теорема Эйлера”, которая является обобщением “малой теоремы Ферма”.

4.1 Функция Эйлера (тотиент) $\phi(N)$

Функция Эйлера (функция $\phi$) для некоторого натурального числа $N$ — это функция, которая возвращает “количество натуральных чисел от 1 до $N$, которые взаимно просты с $N$ (наибольший общий делитель равен 1)”.

Давайте рассмотрим несколько примеров.

$\phi(5)$: Среди 1, 2, 3, 4, 5 взаимно простыми с 5 являются 1, 2, 3, 4 — всего 4 числа. Следовательно, $\phi(5) = 4$.
$\phi(6)$: Среди 1, 2, 3, 4, 5, 6 взаимно простыми с 6 являются 1, 5 — всего 2 числа. Следовательно, $\phi(6) = 2$.

【Особое свойство для простых чисел】 Если $p$ — простое число, все числа от 1 до $p-1$ взаимно просты с $p$. Следовательно,

$$ \phi(p) = p - 1 $$

【Особое свойство для произведения простых чисел】 Для двух различных простых чисел $p$ и $q$, если $N = p \times q$, то $\phi(N)$ можно легко вычислить следующим образом:

$$ \phi(N) = \phi(p) \times \phi(q) = (p - 1)(q - 1) $$

Это свойство служит “потайной дверью” (лазейкой) в алгоритме RSA. Тот, кто знает $p$ и $q$ (создатель ключа), может вычислить $\phi(N)$ за мгновение, но третье лицо, знающее только $N$, не сможет вычислить $\phi(N)$ без разложения $N$ на простые множители.

4.2 Теорема Эйлера

Леонард Эйлер, используя функцию $\phi(N)$, доказал следующую красивую теорему.

Теорема Эйлера: Если целое число $a$ и $N$ взаимно просты, то выполняется следующее сравнение:

$$ a^{\phi(N)} \equiv 1 \pmod N $$

Это удивительное свойство: “если умножить некоторое число $a$ само на себя $\phi(N)$ раз и разделить на $N$, остаток всегда будет равен $1$”. (Если $N$ — простое число $p$, это принимает вид $a^{p-1} \equiv 1 \pmod p$ и называется малой теоремой Ферма).

Давайте преобразуем эту теорему Эйлера. Умножим обе части на $a$ еще раз.

$$ a^{\phi(N) + 1} \equiv a \pmod N $$

Более того, для любого целого числа $k$, $a^{k \cdot \phi(N)}$ также будет равно $1^k = 1$, поэтому выполняется следующее равенство:

$$ a^{k \cdot \phi(N) + 1} \equiv a \pmod N $$

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

5. Алгоритм RSA: Шаги генерации ключей, шифрования и расшифрования

Теперь, когда у нас есть базовые знания, давайте посмотрим на конкретные шаги алгоритма RSA. Алгоритм RSA можно разделить на три основные фазы: “1. Генерация ключей”, “2. Шифрование” и “3. Расшифрование”.

flowchart TD A1["1. Выбрать простые числа p, q"] --> A2["Вычислить N = p × q"] A1 --> A3["Вычислить φ(N) = (p-1)(q-1)"] A3 --> A4["Выбрать e, взаимно простое с φ(N)"] A3 --> A5["Вычислить d такое, что e × d ≡ 1 (mod φ(N))"] A2 --> A6["Открытый ключ (N, e)"] A4 --> A6 A5 --> A7["Закрытый ключ d"] B1["2. Открытый текст (сообщение) M"] --> B2["Вычислить C ≡ M^e (mod N)"] A6 -.-> B2 B2 --> B3["Отправить зашифрованный текст C"] B3 --> C1["3. Полученный зашифрованный текст C"] C1 --> C2["Вычислить M ≡ C^d (mod N)"] A7 -.-> C2 C2 --> C3["Получить исходный открытый текст M"]

5.1 Генерация ключей (Key Generation)

Получатель, Боб, генерирует для себя “открытый ключ” и “закрытый ключ”.

Выбор простых чисел: Случайным образом выбираются два больших простых числа $p$ и $q$.
Вычисление модуля $N$: Вычисляется $N = p \times q$. Это $N$ становится публичным.
Вычисление $\phi(N)$: Вычисляется функция Эйлера $\phi(N) = (p - 1)(q - 1)$. Это секретное число Боба.
Выбор открытого ключа $e$: Выбирается целое число $e$ такое, что $1 < e < \phi(N)$ и $e$ взаимно просто с $\phi(N)$.
Вычисление закрытого ключа $d$: Находится целое число $d$, удовлетворяющее следующему условию: $$ e \times d \equiv 1 \pmod{\phi(N)} $$ Иными словами, “$d$ — это такое число, при котором остаток от деления $e \times d$ на $\phi(N)$ равен $1$”.

На этом подготовка ключей завершена.

Открытый ключ: Пара $(N, e)$. Публикуется для всего мира.
Закрытый ключ: $d$. Никогда никому не передается.

5.2 Шифрование (Encryption)

Допустим, Алиса хочет отправить Бобу секретное сообщение $M$. ($M$ — это числовое представление текста, причем $0 \le M < N$). Алиса использует открытый ключ Боба $(N, e)$ и выполняет следующие вычисления:

$$ C \equiv M^e \pmod N $$

Она вычисляет “остаток $C$ от деления сообщения $M$ в степени $e$ на $N$”. Это $C$ и есть зашифрованный текст.

5.3 Расшифрование (Decryption)

Боб получает зашифрованный текст $C$. Боб использует закрытый ключ $d$ и выполняет следующие вычисления:

$$ M \equiv C^d \pmod N $$

Если вычислить “остаток от деления зашифрованного текста $C$ в степени $d$ на $N$”, то удивительным образом восстанавливается исходное сообщение $M$!

6. Почему расшифрование возвращает исходное сообщение? (Математическое доказательство)

Вы можете задаться вопросом: “Как так получается, что простое возведение $C$ в степень $d$ возвращает нас к исходному $M$?”. Вот тут-то и проявляет свою силу ранее упомянутая “теорема Эйлера”.

Давайте подставим формулу шифрования $C = M^e$ в формулу расшифрования $C^d \pmod N$.

$$ C^d \equiv (M^e)^d \equiv M^{ed} \pmod N $$

Здесь вспомните шаг 5 генерации ключей. Боб при создании $d$ выбрал его так, чтобы выполнялось условие $e \times d \equiv 1 \pmod{\phi(N)}$. Это означает, что “$ed$ — это число, кратное $\phi(N)$, плюс $1$”. Используя целое число $k$, это можно записать следующим образом:

$$ ed = k \cdot \phi(N) + 1 $$

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

$$ M^{ed} = M^{k \cdot \phi(N) + 1} = M^{k \cdot \phi(N)} \times M^1 = (M^{\phi(N)})^k \times M $$

Если предположить, что сообщение $M$ и $N$ взаимно просты, то согласно теореме Эйлера получаем $M^{\phi(N)} \equiv 1 \pmod N$.

$$ (M^{\phi(N)})^k \times M \equiv 1^k \times M \equiv M \pmod N $$

Следовательно, блестяще выполняется следующая формула:

$$ C^d \equiv M \pmod N $$

Алиса не знает $d$, перехватчик тоже не знает $d$, поэтому получить $M$ из $C$ может только Боб, владеющий ключом $d$.

7. Конкретный пример: давайте испытаем RSA вручную, используя небольшие простые числа

Давайте попробуем выполнить зашифрованную связь от Алисы к Бобу на практике, используя небольшие числа (простые числа).

【Фаза генерации ключей Боба】

Выбираем два простых числа $p=11$, $q=13$.
Вычисляем $N = 11 \times 13 = 143$.
Вычисляем $\phi(N) = (11 - 1) \times (13 - 1) = 10 \times 12 = 120$.
Выбираем открытый ключ $e$, взаимно простой с $\phi(N)=120$. Пусть $e=7$.
Находим закрытый ключ $d$. Ищем такое $d$, чтобы выполнялось $7 \times d \equiv 1 \pmod{120}$. В уравнении $7d = 120k + 1$, если $k=6$, получаем $721$, а $721 \div 7 = 103$. Следовательно, $d = 103$.

Открытый ключ: $(N=143, e=7)$
Закрытый ключ: $d=103$

【Фаза шифрования Алисы】 Предположим, мы хотим отправить сообщение $M = 9$. Формула: $C \equiv 9^7 \pmod{143}$ $9^7 = 4,782,969$. Если разделить это число на 143, получим $33447$ с остатком $48$. Зашифрованный текст получился $C = 48$.

【Фаза расшифрования Боба】 Боб получает зашифрованный текст $C = 48$ и использует закрытый ключ $d = 103$ для его расшифрования. Формула: $M \equiv 48^{103} \pmod{143}$ Если запустить на калькуляторе или в программе (48 ** 103) % 143, результат блестяще окажется равным “9”! Исходное сообщение успешно получено.

8. Как найти закрытый ключ $d$: Расширенный алгоритм Евклида

В примере с ручными вычислениями мы нашли $d=103$, подобрав $k$ интуитивно, но если числа состоят из сотен цифр, этот метод не сработает. В реальных программах используется алгоритм, называемый “расширенным алгоритмом Евклида”.

Решить $7d \equiv 1 \pmod{120}$ — это то же самое, что найти целые числа $d$ и $y$, удовлетворяющие уравнению $7d + 120y = 1$. Выполняя алгоритм Евклида в обратном порядке, это можно вычислить механически.

$120 \div 7 = 17$, остаток $1$
Если преобразовать это, получим $1 = 120 - 17 \times 7$
То есть, $-17 \times 7 \equiv 1 \pmod{120}$

В мире по модулю $120$, число $-17$ имеет то же значение, что и $120 - 17 = 103$. Следовательно, мы мгновенно находим $d = 103$. Этот метод позволяет выполнять вычисления очень быстро даже для огромных чисел.

9. Другое лицо RSA: Цифровая подпись

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

При шифровании порядок был таким: “шифрование открытым ключом $\Rightarrow$ расшифрование закрытым ключом”, а в цифровой подписи выполняется процедура “шифрование закрытым ключом $\Rightarrow$ расшифрование открытым ключом”.

flowchart TD A1["1. Алиса создает подпись с помощью закрытого ключа"] --> A2["S ≡ M^d (mod N)"] A2 --> A3["Отправить сообщение M и подпись S"] A3 --> B1["2. Боб проверяет подпись с помощью открытого ключа"] B1 --> B2["Вычислить M' ≡ S^e (mod N)"] B2 --> B3["Проверить, совпадают ли M' и M"]

Алиса использует свой закрытый ключ $d$ для преобразования сообщения (это и есть подпись $S$) и отправляет его Бобу. Боб использует открытый ключ Алисы $e$ для выполнения проверочных вычислений. Если результат вычислений совпадает с исходным сообщением, это одновременно доказывает, что “эти данные могли быть созданы только с помощью закрытого ключа Алисы” и что “сообщение не было изменено в пути”.

10. RSA на практике в коде

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

 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


def gcd(a, b):
 """Найти наибольший общий делитель"""
 while b != 0:
 a, b = b, a % b
 return a

def mod_inverse(e, phi):
 """Найти закрытый ключ d (используется встроенная функция Python 3.8 и выше)"""
 return pow(e, -1, phi)

# 1. Генерация ключей
p, q = 11, 13
N = p * q
phi = (p - 1) * (q - 1)
e = 7
d = mod_inverse(e, phi)

print(f"Открытый ключ: (N={N}, e={e}), Закрытый ключ: d={d}")

# 2. Шифрование
message = 9
ciphertext = pow(message, e, N)
print(f"Зашифрованный текст: {ciphertext}")

# 3. Расшифрование
decrypted_message = pow(ciphertext, d, N)
print(f"Расшифрованное сообщение: {decrypted_message}")

Функция pow(base, exp, mod) в Python внутри использует быстрый алгоритм, называемый “алгоритмом возведения в степень справа налево” (быстрое возведение в степень по модулю), поэтому вычисления для чисел из сотен цифр завершаются мгновенно.

11. Заключение и будущее криптографии

Основываясь на знаниях школьной математики, мы разобрали механизмы работы алгоритма RSA.

Сложность факторизации: Легко вычислить $p \times q = N$, но очень сложно найти $p, q$ по заданному $N$.
Сравнения и теорема Эйлера: Благодаря закону $a^{\phi(N)} \equiv 1 \pmod N$ создается волшебная потайная дверь, позволяющая “вернуться к исходному значению при возведении в определенную степень”.
Открытый и закрытый ключи: Зашифровать может кто угодно, но расшифровать способен только законный получатель.

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

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