数学 on kenji.blog

【完全解剖】使用C++实现并理解最强密码破解算法「GNFS」

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

【完全解剖】使用C++实现并理解最强密码破解算法「GNFS」

支撑现代互联网根基的「RSA加密」。其坚固性依赖于一种数学信念：“以目前的计算机，想要对巨大的合数进行素数分解实际上是不可能的”。

然而，人类从未放弃。如今，在经典计算机（非量子计算机）上，存在着一种用于进行巨大素数分解的 **人类最强、最尖端的算法 **。那就是 「一般数域筛选法（GNFS：General Number Field Sieve）」。

本文将完全公开使用C++（使用了Boost库的多精度整数 boost::multiprecision）严格建模这一GNFS最尖端计算逻辑的实现代码，并彻底解说其背后的「代数数论」深渊。

请务必结合源代码，尽情领略数学的神秘以及将其征服的计算机科学的暴力美学。

1. GNFS 最尖端逻辑框架（完整源代码）

首先，展示本次要解说的GNFS C++实现的整体面貌。实际的数域筛选法（如CADO-NFS等）是长达数十万行的超大型分布式系统，而本代码提取了构成GNFS的 「5个必备流水线（阶段）」 进行类设计，并在不丢失数学意义的前提下以最小结构进行了建模。

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


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

// 使用Boost.Multiprecision的多精度整数
using namespace boost::multiprecision;

// ============================================================================
// [SOTA GNFS] General Number Field Sieve (一般数域筛选法) 最尖端逻辑框架
//
// 本代码将CADO-NFS等使用的最尖端GNFS的5个流水线
// 严格建模为C++ (Boost) 的类设计。
// ============================================================================

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

// ============================================================================
// Phase 1: Polynomial Selection (KleinJung算法)
// ============================================================================
class PolynomialSelector {
public:
 int degree;
 std::vector<cpp_int> f; // 代数侧多项式 f(x)
 std::vector<cpp_int> g; // 有理侧多项式 g(x) = x - m
 cpp_int m;

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

 // 基于 base-m 展开生成初始多项式 (实际使用更高级的格基规约 LLL)
 void select(const cpp_int& N) {
 std::cout << "[Phase 1] Polynomial Selection (Degree " << degree << ") starting..." << std::endl;
 // 简单的 base-m 展开 (d次)
 // m = N^(1/d)
 cpp_int N_copy = N;
 m = 1;
 // 简单的m估算 (不使用Boost函数的近似)
 cpp_int low = 1, high = N;
 while (low <= high) {
 cpp_int mid = low + (high - low) / 2;
 cpp_int p = 1;
 for(int i=0; i<degree; ++i) p *= mid;
 if (p <= N) { m = mid; low = mid + 1; }
 else { high = mid - 1; }
 }

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

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

 std::cout << " -> m = " << m << std::endl;
 std::cout << " -> f(x) = ";
 for(int i = degree; i >= 0; --i) {
 std::cout << f[i] << "x^" << i << (i > 0 ? " + " : "");
 }
 std::cout << "\n[Phase 1] Complete." << std::endl;
 }
};

// ============================================================================
// Phase 2: Lattice Sieving (格筛选法)
// ============================================================================
// 近年的GNFS中，相较于线筛选 (Line Sieve)，Franke-Kleinjung等人的
// 特殊q格筛选 (Special-q Lattice Sieving) 是事实上的标准。
class LatticeSieve {
 uint32_t rational_bound;
 uint32_t algebraic_bound;
 std::vector<uint32_t> rational_fb;
 std::vector<uint32_t> algebraic_fb;

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

 void generate_factor_bases() {
 std::cout << "[Phase 2] Generating Factor Bases (Rational Bound: " << rational_bound << ", Algebraic Bound: " << algebraic_bound << ")" << std::endl;
 // (省略) 实际上会进行素数生成以及利用勒让德符号等进行过滤
 }

 std::vector<Relation> sieve(const PolynomialSelector& poly) {
 std::cout << "[Phase 2] Special-q Lattice Sieving active..." << std::endl;
 std::vector<Relation> relations;
 // 模拟实现: 实际的格筛选会以块为单位扫描数百GB的内存空间
 // 将 (a, b) 的对映射到每个特殊素数 q 的格子 (a = i*q + j*...) 上，
 // 执行将缓存效率提升到极限的筛选。

 // 为演示添加一个虚拟关系
 Relation r; r.a = 17; r.b = 3;
 r.rational_primes = {2, 5};
 r.algebraic_primes = {3, 7};
 relations.push_back(r);

 std::cout << "[Phase 2] Found " << relations.size() << " relations." << std::endl;
 return relations;
 }
};

// ============================================================================
// Phase 3: Filtering (奇异点清除与团合并)
// ============================================================================
class Filter {
public:
 void reduce_matrix(std::vector<Relation>& relations) {
 std::cout << "[Phase 3] Filtering Relations..." << std::endl;
 // 1. Singleton removal (删除仅出现1次的素数所对应的关系)
 // 2. Clique merging (合并关系以使稀疏矩阵变稠密)
 // 实际上会使用并查集等算法将数亿行的矩阵压缩到数百万行。
 std::cout << "[Phase 3] Matrix size reduced optimally." << std::endl;
 }
};

// ============================================================================
// Phase 4: Linear Algebra over GF(2) (Block Wiedemann 法)
// ============================================================================
class LinearAlgebraGF2 {
public:
 // 在近年的超算环境中，比起 Block Lanczos 法，更适合分布式计算的
 // Block Wiedemann 法 (Coppersmith实现) 被作为最尖端技术使用。
 std::vector<std::vector<int>> solve_nullspace(const std::vector<Relation>& relations) {
 std::cout << "[Phase 4] Block Wiedemann algorithm over GF(2) starting..." << std::endl;
 // 迭代进行稀疏矩阵与向量的乘积运算，
 // 找到多个满足 M * x = 0 mod 2 的解向量(零空间)。

 std::vector<std::vector<int>> dependencies; // 依赖关系列表
 // 虚拟数据
 dependencies.push_back({0});

 std::cout << "[Phase 4] Found " << dependencies.size() << " linear dependencies (perfect squares)." << std::endl;
 return dependencies;
 }
};

// ============================================================================
// Phase 5: Algebraic Square Root (代数平方根)
// ============================================================================
class AlgebraicSquareRoot {
public:
 void compute_and_factor(const std::vector<Relation>& relations, const std::vector<int>& dep, const cpp_int& N) {
 std::cout << "[Phase 5] Algebraic Square Root computation..." << std::endl;

 // 1. 有理侧平方根 V 的计算 (简单的整数运算)
 cpp_int V = 1;
 // V = sqrt( prod(a - bm) ) mod N

 // 2. 代数侧平方根 gamma 的计算 (Montgomery法等)
 // 求出巨大代数域 O_K 的元素 gamma，并通过同态映射 phi 映射到现实世界
 // Y = phi(gamma) mod N
 cpp_int Y = 1;

 // 为了回避理想类群与单位群的障碍(Obstruction)，
 // 前提是在Phase 2和4中添加了二次剩余特征(Quadratic Characters)的列。

 std::cout << " -> Homomorphism map phi applied." << std::endl;
 std::cout << "[Phase 5] Calculating GCD(V - Y, N)..." << std::endl;

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

 if (factor > 1 && factor < N) {
 std::cout << "\n================================================================" << std::endl;
 std::cout << "[SUCCESS] Non-trivial factor found: " << factor << std::endl;
 std::cout << " Other factor: " << N / factor << std::endl;
 std::cout << "================================================================" << std::endl;
 } else {
 std::cout << "[FAILURE] Trivial solution. Trying next dependency..." << std::endl;
 }
 }
};

// ============================================================================
// Main Execution Pipeline
// ============================================================================
int main() {
 std::cout << "================================================================" << std::endl;
 std::cout << " [SOTA GNFS] General Number Field Sieve Engine (Boost C++) " << std::endl;
 std::cout << "================================================================" << std::endl;

 // 想要进行素数分解的巨大合数 N (如 RSA-270 等)
 cpp_int N("233108530344407544527637656910680524145619812480305449042948611968495918245135782867888369318577116418213919268572658314913060672626911354027609793166341626693946596196427744273886601876896313468704059066746903123910748277606548649151920812699309766587514735456594993207");

 // 多项式的次数 (超过130位时通常选择 5次～6次)
 int degree = 6;

 // 初始化流水线
 PolynomialSelector poly_select(degree);
 LatticeSieve sieve(10000000, 20000000); // 实际的界限在数千万到数亿
 Filter filter;
 LinearAlgebraGF2 linalg;
 AlgebraicSquareRoot sqrt_step;

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

 // 1. 多项式选择
 poly_select.select(N);

 // 2. 筛选 (Sieve) 处理
 sieve.generate_factor_bases();
 std::vector<Relation> relations = sieve.sieve(poly_select);

 // 3. 过滤 (矩阵压缩)
 filter.reduce_matrix(relations);

 // 4. 线性代数 (GF(2)上的零空间搜索)
 std::vector<std::vector<int>> dependencies = linalg.solve_nullspace(relations);

 // 5. 代数平方根的计算与GCD
 for (const auto& dep : dependencies) {
 sqrt_step.compute_and_factor(relations, dep, N);
 }

 auto end_time = std::chrono::high_resolution_clock::now();
 std::chrono::duration<double> elapsed = end_time - start_time;
 std::cout << "\n[System] SOTA GNFS Pipeline completed in " << elapsed.count() << " seconds." << std::endl;

 return 0;
}

那么，这段代码究竟是如何突破加密壁垒的呢？接下来，我们将按5个阶段，将其严密的算法与高深的数学揉碎了进行解说。

2. GNFS的最终目的： $X^2 \equiv Y^2 \pmod N$

不仅是GNFS，现代巨大的素因数分解算法几乎都在追求一个共同的目标：找到满足以下同余式的非平凡对 $(X, Y)$。

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

这个式子意味着，“$X^2$ 和 $Y^2$ 除以 $N$ 的余数相等”。将其变形可得， $X^2 - Y^2 \equiv 0 \pmod N$ 也就是说，$(X-Y)(X+Y)$ 是 $N$ 的倍数。

如果 $X \not\equiv \pm Y \pmod N$（非平凡解），那么在 $(X-Y)$ 和 $N$ 之间就存在一个“大于1且小于 $N$ 的公约数”。此时，使用辗转相除法计算 $\gcd(X-Y, N)$，就可以轻而易举地求出 $N$ 的素因子。

然而，要找到这样的 $X$ 和 $Y$ 无异于大海捞针。因此GNFS采取了一种天才般的方法，即创造出“现实的整数世界”和“多项式的代数域世界” 这两个世界，并将计算分散开来。

3. Phase 1: 多项式选择（Polynomial Selection）

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


class PolynomialSelector {
 // ...
 void select(const cpp_int& N) {
 // m = N^(1/d) 的计算与 base-m 展开
 // ...
 for (int i = 0; i <= degree; ++i) {
 f[i] = temp % m;
 temp /= m;
 }
 g = {-m, 1}; // g(x) = x - m
 }
};

GNFS的第一步，是构建连接两个世界的“魔法多项式”。对于巨大的数 $N$，我们选取一个整数 $m$。通常选取 $m \approx N^{1/d}$（代码中假设为 $d=6$ 次多项式）。

然后，将 $N$ 展开为 $m$ 进制，利用其系数构建多项式 $f(x)$。

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

这个多项式 $f(x)$ 具有一个极其重要的性质：“当变量 $x$ 代入 $m$ 时，结果正好是 $N$（$f(m) = N$）”。换句话说，$f(m) \equiv 0 \pmod N$。有理侧的多项式定义为 $g(x) = x - m$。

这样，由 $f(x)=0$ 的根 $\alpha$ 所支配的 “代数域世界 $\mathbb{Z}[\alpha]$”，与普通的 “有理数（整数）世界 $\mathbb{Z}$”，通过 $x \to m$ 的“环同态映射（Homomorphism）”被紧密地连接在了一起。

在最尖端的CADO-NFS等实现中，会花费数月时间，利用KleinJung算法或LLL格基规约算法，去搜索一个多项式系数不会极大，并且在后续步骤中更容易出现素数（更容易平滑）的“最合适的多项式 $f(x)$”。

4. Phase 2: 特殊 $q$ 格筛选法（Special-q Lattice Sieving）

1
2
3
4
5
6
7
8
9


class LatticeSieve {
 // ...
 std::vector<Relation> sieve(const PolynomialSelector& poly) {
 // ...
 // 将 (a, b) 的对映射到每个特殊素数 q 的格子中，
 // 执行将缓存效率提升到极限的筛选。
 // ...
 }
};

准备好两个世界后，下一步就是在这两个世界中寻找“平滑数（仅由小素数组成的数）”。生成无数个整数对 $(a, b)$，并计算以下两个值：

有理侧的值 ： $a - bm$
代数侧的范数 ： $b^d f(a/b)$

GNFS的目的是收集几千万到几亿个 “有理侧和代数侧的值都能被小素因子完全分解的整数对（Relation：关系）”。

在早期的GNFS中，使用“线筛选（Line Sieve）”，即把 $(a, b)$ 排列在 $xy$ 平面上，从头开始依次用素数去除。然而，这种做法会导致在内存各处跳跃访问，引发频繁的缓存未命中，速度非常慢。

因此，在当前的尖端代码中使用了 “特殊 $q$ 格筛选（Special-q Lattice Sieve）” 技术。固定一个适度大的素数 $q$，只把那些“代数侧的值必然能被 $q$ 整除的 $(a, b)$ 对”作为计算对象。满足这个条件的 $(a, b)$ 在平面上形成了一个“格子（Lattice）”，使得计算内存地址的跳跃幅度固定，完美契合CPU的L1/L2缓存。通过引入格筛选，GNFS的计算速度得到了戏剧性的提升。

5. Phase 3: 过滤（Filtering）

1
2
3
4
5
6
7


class Filter {
public:
 void reduce_matrix(std::vector<Relation>& relations) {
 // 1. Singleton removal (删除仅出现1次的素数所对应的关系)
 // 2. Clique merging (合并关系以使稀疏矩阵变稠密)
 }
};

Phase 2中全球计算机花费数月收集到的数亿个关系。但是，如果直接将这些关系丢给下一个“解方程组步骤（矩阵计算）”，超级计算机的内存也会被撑爆。

因此，需要进行称为 Filtering（过滤） 的矩阵超压缩过程。

Singleton removal（奇异点清除） 假设一个巨大的素数 $p$ 在数亿个关系中“仅仅出现了一次”。因为我们的目标是“让所有素数的指数都变为偶数（2的倍数）”，所以只出现一次的素数是绝对无法变成偶数的。因此，包含该素数的关系会被视为“无用的垃圾”立即删除（清除）。由于这会引起连锁反应，原本数亿行的数据会迅速减少。
Clique merging（团合并） 进一步地，将共享特定素数的关系互相相乘（相加），从而在减少行数的同时，把稀疏（空洞多）的矩阵压缩成更稠密的状态（使用类似图论中的团搜索技术）。

通过这种优化，巨大的稀疏矩阵被戏剧性地压缩到了可以计算的规模。

6. Phase 4: GF(2) 上的线性代数（Block Wiedemann法）

1
2
3
4
5
6
7


class LinearAlgebraGF2 {
public:
 std::vector<std::vector<int>> solve_nullspace(const std::vector<Relation>& relations) {
 // 迭代进行稀疏矩阵与向量的乘积运算，
 // 找到多个满足 M * x = 0 mod 2 的解向量(零空间)。
 }
};

终于到了拼图的核心。将收集到的关系相乘，寻找 “所有素因子的指数都变成偶数次方的组合”。

这在数学上等同于，用一个元素为各素数指数的“偶数/奇数（即0或1）”的巨大矩阵 $M$，和一个表示使用哪些关系的向量 $x$，求解满足 $M \cdot x \equiv 0 \pmod 2$ 的解向量 $x$（零空间、核）。

我们需要解开数百万行 × 数百万列这种惊人规模矩阵的联立方程式。如果使用普通的高斯消元法，计算复杂度将达到 $O(N^3)$，即使到宇宙终结也算不完。

因此，最尖端的实现采用了 “Block Wiedemann（分块维德曼）法”。这是一种Krylov子空间法，利用矩阵 $M$ “非常稀疏（几乎全是0）”的特点，通过迭代进行矩阵与向量的乘法运算来推导出解。与传统的Block Lanczos法不同，Block Wiedemann法可以将计算过程完全分割给多个集群，因此在现代的分布式云计算或超级计算机的并行计算中能发挥压倒性的威力。

7. Phase 5: 代数平方根（Algebraic Square Root）与密码的崩溃

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


class AlgebraicSquareRoot {
public:
 void compute_and_factor(...) {
 // 1. 有理侧平方根 V 的计算
 cpp_int V = 1;

 // 2. 代数侧平方根 gamma 的计算
 cpp_int Y = 1;

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

通过Phase 4的矩阵计算，我们得到了“一旦相乘，所有素因子都会变为偶数次方的关系集合 $S$”。借此，我们能够在有理侧和代数侧各自的世界中构建出“平方”。

有理侧只是简单的整数乘法，计算平方根 $V$ 很容易。

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

然而，真正的地狱在于“代数侧”。 在代数域的世界 $\mathbb{Z}[\alpha]$ 中，素因子分解的唯一性不成立，因此我们一直使用理想（Ideal）进行计算。矩阵计算所保证的仅仅是 “成为了理想的平方”，而并未保证“成为元素的平方（$\gamma^2$）”。

在此，代数数论中两堵坚固的高墙——“理想类群的障碍”与“单位群的障碍”——拦住了去路。在GNFS中，为了打破这堵墙，使用了 “二次剩余特征（Quadratic Characters）” 这种魔法。即在Phase 4的矩阵中，事先悄悄加入了针对数十个特定素理想的二次剩余（勒让德符号）列。这样一来，找到的集合 $S$ 就能以压倒性的概率绕过障碍，顺利形成“真正的元素平方 $\gamma^2$”。

求 $\gamma$ 的过程（代数平方根）使用了如Montgomery法等极其复杂的算法。

最后，通过环同态映射 $\phi$（将 $x$ 替换为 $m$），把代数侧的平方根 $\gamma$ 传送回现实世界，得到 $Y$。只要将有理侧的 $V$ 直接作为 $X$，我们一直追求的绝对等式便终于完成了。

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

剩下的就只是计算 $\gcd(X-Y, N)$ 了。经过0.001秒的短暂运算，当非平凡因子打印在屏幕上的那一刻，曾被认为坚不可摧的RSA加密便彻底崩溃了。

结语

GNFS绝非仅仅是编程技巧。它是将抽象代数、环论、理想类群等“纯数学的深渊”，用超级计算机的分布式架构和缓存优化等“极限工程学”加以征服后的人类智慧结晶。

我们平日里漫不经心发送的聊天信息或信用卡数据，正是被建立在这种天文级别的数学攻防之上的系统所保护着。

希望通过这个C++框架，能让您感受到最尖端密码破解算法背后蕴藏的“数学与计算机的浪漫”。

一般数域筛法（GNFS）的真正数学结构

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

一般数域筛法（GNFS）的真正数学结构

GNFS的最终目标是找到满足 $X^2 \equiv Y^2 \pmod N$ 的 $X, Y$。为了实现这一目标，数学家们在 “现实的整数世界” 与 “代数数域的世界” 之间架起了一座桥梁。这座桥梁就是“同态映射”。

第一阶段：连接世界的“同态映射（Homomorphism）”

1. 多项式的选择与根的定义

对于巨大的合数 $N$，选择一个整数 $m$ 和多项式 $f(x)$，使得 $f(m) \equiv 0 \pmod N$。（例如：将 $N$ 展开为 $m$ 进制数，由其系数构造 $f(x)$。此时假设 $f(x)$ 在有理数域 $\mathbb{Q}$ 上是不可约的（即无法再进行因式分解））。

接着，将方程式 $f(x) = 0$ 在“复数范围内的根”之一设为 $\alpha$。显然，$f(\alpha) = 0$。$\alpha$ 不是整数，而是包含根号或虚数等复杂的数（代数数）。

2. 环（Ring）与同态映射的构建

在这里，准备两个数学上的“环（定义了加法和乘法的世界）”。

世界A： $\mathbb{Z}[\alpha]$ （包含 $\alpha$ 的代数整数环）这是一个由形如 $a + b\alpha + c\alpha^2 + \dots$ 的数构成的世界。
世界B： $\mathbb{Z}/N\mathbb{Z}$ （模 $N$ 剩余环）这是一个仅由 $0$ 到 $N-1$ 的整数构成的同余（模）世界。

此时，定义一个从世界A到世界B的映射 $\phi$： $$\phi : \mathbb{Z}[\alpha] \to \mathbb{Z}/N\mathbb{Z}$$ $$\phi(\alpha) = m \pmod N$$

这个映射 $\phi$ 是一种魔法操作，它能将世界A中的变量 $\alpha$ 原封不动地替换为世界B中的整数 $m$。这个 $\phi$ 具有极强的性质，被称为 “环同态映射（Ring Homomorphism）”。同态的含义是，“在不破坏加法和乘法结构的前提下，使其跃迁到另一个世界” 的性质。也就是说，以下公式成立：

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

这意味着什么呢？如果我们在“世界A（$\alpha$的世界）”中，能够构造出某个复杂元素 $\gamma$ 的 “平方（$\gamma^2$）”，那么即使通过 $\phi$ 将其跃迁到“世界B（余数的世界）”，** 也能完美保持平方的形式 $\phi(\gamma)^2$**。

第二阶段：质因数分解的崩溃与“理想（Ideal）”的诞生

在世界A（$\mathbb{Z}[\alpha]$）中，我们希望收集大量合适的元素 $(a - b\alpha)$，并将它们相乘，从而制造出一个“完全平方（平方元）”。通常情况下，只需将收集到的每个 $(a - b\alpha)$ 分别进行“质因数分解”，然后组合起来（通过矩阵求解）使得所有质数的指数都为偶数，就能构造出平方。

然而，此时代数学的一堵令人绝望的墙壁挡在了面前。 在像 $\mathbb{Z}[\alpha]$ 这样的代数数域世界中，我们在中学学到的 “质因数分解的唯一性（任何数都能且仅能以一种方式表示为质数的乘积）”崩溃了。

（例如：在某个代数数域世界中，$6 = 2 \times 3$，同时 $6 = (1+\sqrt{-5}) \times (1-\sqrt{-5})$，这就让人无法分辨到底哪个才是真正的质数）

如果质因数分解无法唯一确定，那么“统计质数个数使其成对（偶数个）”的拼图游戏（筛法）在原理上就无法执行。

库默尔与戴德金的拯救：“理想”

拯救这一崩溃局面的，是19世纪数学家所创造的 “理想（Ideal：理想数）” 概念。通过考虑该元素所生成的“倍数集合（理想）”而不是元素本身，再次使质因数分解成为可能。

在代数数域的整数环 $\mathcal{O}_K$（包含 $\mathbb{Z}[\alpha]$ 的更完备的环）中，即使元素本身无法进行唯一的质因数分解，数学上已经证明了 “理想一定能唯一地分解为‘素理想（$\mathfrak{p}$）’的乘积”。

因此，在GNFS中，不是去分解元素 $(a - b\alpha)$ 本身，而是将其生成的 主理想 $\langle a - b\alpha \rangle$ 进行素理想分解。

第三阶段：范数（Norm）与双筛法（Sieve）

那么，如何知道理想 $\langle a - b\alpha \rangle$ 会分解成哪些素理想呢？这里使用了 “范数（Norm）” 函数。范数是一个将代数数域中的复杂元素转换为“普通现实整数 $\mathbb{Z}$”的函数。

元素 $(a - b\alpha)$ 的范数可以通过计算一个简单的多项式 $b^d f(a/b)$ 求得（$d$ 为 $f(x)$ 的次数）。

根据代数定理，“如果某个理想的范数能够被小质数完全分解（即是平滑的），那么它原本的理想也能被小的素理想完全分解”。

因此，GNFS针对数千万对整数对 $(a, b)$，同时计算以下两个值，并只收集那些两个值都是“平滑数”的配对。

有理筛（Rational Sieve）： $a - bm$ （现实世界的值）
代数筛（Algebraic Sieve）： $b^d f(a/b)$ （代数数域世界中的范数）

收集数千万个两者皆平滑的配对 $(a, b)$，将其理想的质因数分解数据（包含多少个素理想）构建为巨大的矩阵（GF(2)上的线性代数）进行求解，从而找到一个配对集合 $S$，使得“将它们相乘后，所有素理想的指数均为偶数”。

第四阶段：两道“障碍”的阻挡与理想类群

通过矩阵计算，我们发现将集合 $S$ 中所有的 $(a - b\alpha)$ 理想相乘，会得到某个理想 $I$ 的平方。

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

然而，这还没有结束。GNFS中最深奥、最困难的数学壁垒就在这里。

我们最终想要的，不是“理想的平方”，而是可以代入映射 $\phi$ 中的 “元素的平方（$\gamma^2$）”。理想成了平方，并不意味着元素本身也是平方。这里存在着 两大极其棘手的数学障碍（Obstruction）。

障碍①：理想类群（Ideal Class Group）的壁垒

理想 $I$ 未必是“由单个元素生成的主理想”。我们不可能从一个非主理想的理想中，提取出具体的元素 $\gamma$。

在这里，“理想类群（Class Group, $Cl_K$）” 的概念登场了。理想类群是一个衡量“在该代数数域世界中，存在多少个非主理想的理想（质因数分解的唯一性被破坏到了什么程度）”的群。即使 $\prod \langle a - b\alpha \rangle$ 变成了 $I^2$，如果 $I$ 在理想类群中不是单位元（主理想），就无法将其拉回到元素的平方。

障碍②：单位群（Unit Group）的壁垒

假设我们运气很好，$I$ 恰好是主理想 $\langle \gamma \rangle$。那么，$\prod \langle a - b\alpha \rangle = \langle \gamma^2 \rangle$。你可能会想：“太好了，元素也是平方了！”，但这大错特错。

理想（倍数的集合）相等，并不意味着元素完全相等。它们之间必然会产生 “单位（Unit：其倒数也是整数的数。如 1 或 -1 等）” 的偏差。也就是说，实际元素的等式如下所示：

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

（$u$ 为单位群 $U_K$ 的元素）

如果这个单位 $u$ 本身不是某个数的平方（平方元），那么等式左边绝对无法成为“完全的元素平方”。

第五阶段：阿德曼的魔法“二次剩余特征（Quadratic Characters）”

理想类群的障碍与单位群的障碍。如何跨越这两个障碍呢？这时，密码学家伦纳德·阿德曼（RSA中的"A"）等人引入的天才手法 “二次剩余特征（Quadratic Characters）” 发挥了作用。

为了判断“某个元素在代数数域中是否完全是平方？”，我们使用了勒让德符号（二次剩余）的代数数域版本。在之前的巨大矩阵（为了让素理想个数变为偶数而拼凑的矩阵）中，悄悄增加几十个额外的条件（列），要求“对于几个特定的素理想 $\mathfrak{q}$，其二次剩余特征也都必须为 $1$（偶数）”。

当通过矩阵计算找到连这些附加条件也能满足的集合 $S$ 时，代数数论的深层定理保证了：“理想类群的障碍和单位群的障碍，都将以压倒性的概率自然消灭”。

由此，我们终于得到了真正的等式：

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

最终阶段：世界的融合与密码的崩溃

至此，拼图的所有碎片都已集齐。

【代数数域世界（世界A）的元素】 $\gamma^2 = \prod (a - b\alpha)$ （使用平方根算法求出 $\gamma$）

【现实世界（有理数世界）的元素】 $V^2 = \prod (a - bm)$ （这里只是简单的整数乘法，可以直接求出平方根 $V$）

现在，最开始建造的魔法桥梁——同态映射 $\phi$ 终于要登场了。将世界A的元素 $\gamma$，通过 $\phi$（将 $\alpha$ 替换为 $m$ 的映射），跃迁到世界B（模 $N$ 余数的世界）。

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

另一方面，将现实世界中求出的 $V$，直接带入余数世界作为 $X$。

$$X = V \pmod N$$

得益于同态映射“保持结构”的性质，在世界A中成立的平方关系，在世界B（模 $N$ 的世界）中也得到了完美的保存。此外，由于最初的配对 $(a, b)$ 是以 $a - b\alpha$ 和 $a - bm$ 的形式对应生成的，这个 $X$ 和 $Y$ 将在模 $N$ 的世界中发生碰撞，产生以下绝对的等式：

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

接下来，只需祈祷这个 $X$ 和 $Y$ 不是平凡解（$X \equiv \pm Y$），然后计算： $\gcd(X - Y, N)$

如果是非平凡解，欧几里得辗转相除法将在 0.001 秒内跑完，RSA密码的心脏——秘密质数 $p$ 和 $q$ ——将被打印在输出屏幕上。

这就是汇集了现代数学精华的 “一般数域筛法（GNFS）”的完整面貌。

破解互联网密码的人类最强数学“一般数域筛选法（GNFS）”是什么？

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

破解互联网密码的人类最强数学“一般数域筛选法（GNFS）”是什么？

我们每天使用的互联网，无论是LINE消息、YouTube还是在Amazon上购物，所有的通信都受到“密码”的保护。目前，全世界使用最广泛的密码代表就是“RSA密码”。

RSA密码防御的核心非常简单。那就是利用了 “即使是计算机也无法解开巨大数字的质因数分解” 这一数学性质。例如，如果是“15”，我们很快就能知道是“3 × 5”，但如果这变成一个“270位的数字”，即使把全世界的超级计算机联合起来，也需要几亿年才能解开。

然而，数学家们也没有沉默。为了打破这个坚不可摧的密码，人类创造出了一种如同魔法般的算法（计算步骤）——“一般数域筛选法（GNFS：General Number Field Sieve）”。

在这篇文章中，我们将不使用任何专业术语，仅凭 初中学的数学知识（质因数分解、代数式、最大公约数），分步为您完全解析这个“人类最强算法”破解密码的奥秘！

第1章：密码破译的目标是“初三的公式”

面对巨大的质因数分解，最大的必杀技就是初三年级学的这个公式。

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

你可能会想：“哎，这么基础的公式就能破解密码吗？”但正是这个公式，是解开一切的大师级钥匙。

破解密码的最大目标，是对于一个巨大的数字 $N$，找到 “将 $X^2$ 和 $Y^2$ 除以 $N$ 后的余数相同的数字（$X$ 和 $Y$）”。

为什么“余数相同”就能解开密码？

假设有两个数字 $X^2$ 和 $Y^2$，“除以 $N$ 的余数相同”。余数相同意味着，做减法得到的“$X^2 - Y^2$”，必定能被 $N$ 整除（成为 $N$ 的倍数），这是一个法则。

这里，假设用于密码的巨大数字 $N$ 是由两个秘密的质数（$p$ 和 $q$）相乘得到的（$N = p \times q$）。

将 $X^2 - Y^2$ 进行因式分解，就变成了 $(X - Y)(X + Y)$。这既然是 $N$ 的倍数，就意味着在这个乘法中的某个地方，隐藏着秘密的质数 $p$ 和 $q$。

奇迹在此发生。这两个质数 $p$ 和 $q$，“$p$ 进入 $(X - Y)$ 的房间”、“$q$ 进入 $(X + Y)$ 的房间”，被分到不同房间的概率，在数学上是 ** 50%（二分之一）**。

在只有质数 $p$ 进入了 $(X - Y)$ 房间的状态下，让我们来计算 $(X - Y)$ 和 $N$ 的 “最大公约数（最大的共同部分）”。

$(X - Y)$ 的内容＝ $p \times$ 某个数
$N$ 的内容＝ $p \times q$ 共同的部分只有 “$p$” 吧！

也就是说，在计算出最大公约数的瞬间，隐藏着的质数 $p$ 就会掉落出来，密码也就被完全破译了。（※使用“辗转相除法”，即使在智能手机上也能瞬间计算出最大公约数）

【小专栏：为什么是平方？三次方或两倍不行吗？】

如果是“$2X - 2Y$”，就会变成 $2(X - Y)$，因为只有一个房间，所以无法分离出质数。如果是“$X^3 - Y^3$”，房间的大小会变得不平衡，计算量会无谓地增加。为了将质数分离成两个，能优美地分成两个房间的“平方”性价比最高。

第2章：如何寻找X和Y？“收集质数卡片的拼图”

目标已经明确。然而，即使盲目地去寻找“余数相同的 $X^2$ 和 $Y^2$”，直到宇宙寿命结束也找不到。于是，数学家们想出了一个极其天才的方法，称为 “收集质数卡片的拼图”。

Step 1：用筛子只收集沙金（平滑数）

首先，准备一个随意的数字 $Z$，计算其平方后除以 $N$ 的余数 $W$。（$Z^2 = W$ 的余数世界）

将得到的余数 $W$ 进行质因数分解。这里，只有当出现 “仅由 2, 3, 5, 7 等小质数组成的 $W$” 时，才将该式子作为“中奖卡片”保留下来；如果混杂了大的质数就丢掉。这就好比在河里用筛子把大石头过滤掉，只收集沙金一样的作业。

Step 2：全部变成“偶数个”的拼图

例如，假设收集到了以下 3 张沙金卡片：

卡片A： $Z_1^2 = 2^3 \times 3^1$
卡片B： $Z_2^2 = 2^1 \times 5^1$
卡片C： $Z_3^2 = 3^1 \times 5^1$

我们把它们全部相乘看看。右侧变成 $(2^3 \times 3^1) \times (2^1 \times 5^1) \times (3^1 \times 5^1)$，整理后变成 “$2^4 \times 3^2 \times 5^2$”。

不可思议的是，质数的个数变成了“4个、2个、2个”，全部都是偶数个！全部都是偶数个，意味着把整体的个数减半，就会变成“某个数的平方”。也就是说，$(2^2 \times 3^1 \times 5^1)^2 = (60)^2$。

左侧是 $(Z_1 \times Z_2 \times Z_3)^2$，这样一来，终于 $X = (Z_1 \times Z_2 \times Z_3)$ $Y = 60$ 这组期待已久的“$X^2 = Y^2$”就完成了！

对于计算机来说，计算质数个数是“偶数还是奇数（0还是1）”的拼图是它非常擅长的，所以用这种方法能高速地找到 $X$ 和 $Y$。

第3章：阻挡在前的绝望之墙

这样就能解开任何密码了！……正当这么想时，大问题发生了。如果密码数字 $N$ 在“100位”左右，用这个方法（称为二次筛选法）还能解开；但如果 $N$ 变成“200位、300位”，计算途中出现的 $W$ 就会变得太大。

数字太大的话，“仅由小质数组成的数（沙金）”就会彻底不再出现。这会变得比在沙漠里找隐形眼镜还难，完全收集不到用来解开拼图的卡片。

在这里，人类的终极武器 “一般数域筛选法（GNFS）” 终于登场了。

第4章：人类最强的点子，创造“两个世界”

GNFS 的天才构想是：“因为只在现实世界里计算，所以数字才会变大。那么，就创造一个使用多项式（代数式）的『里世界』，把计算的负担分散成两份吧。”

代数式的魔法

GNFS 利用一个基准数 $m$，将巨大的数字 $N$ 转换为代数式。例如，如果 $N=100$，设 $m=4$，则 $100 = 4^3 + 2(4^2) + 4$。使用字母 $x$，将其变为 $f(x) = x^3 + 2x^2 + x$ 这样一个式子（里世界）。

这个式子有趣的地方在于，它具有 “只要将 $m$（上例中是4）代入字母 $x$，就随时能穿越回到现实的数字 $N$” 这一性质。

在两个世界同时寻找沙金

GNFS 会制造许多随意的整数对 $(a, b)$，并同时进行以下两个计算：

现实世界： $a - b \times m$
代数式世界：用代数式的规则计算出的 $a - b \times x$ 的值

通过将问题分为两个世界，所处理的数字尺寸就会剧烈减小（变轻）。这就像是把一块巨岩劈成两半，变成易于处理的石块的感觉。

然后，只有当 “在现实世界和代数式世界中，两边都『仅由小质数组成（沙金）』” 时，才用筛子把这种奇迹般的数对 $(a, b)$ 筛选出来并收集。这就是“数域筛选法”这个名字的由来。

密码终于被破译的瞬间

当从两个世界收集到数千万张“沙金卡片”后，就利用超级计算机庞大的矩阵计算，找出在第2章做过的“质数个数全部变成偶数的组合”。

找到组合后：

将在现实世界中形成的平方数设为 $X^2$
将在代数式世界中形成的平方代数式设为 $Y(x)^2$

最后，将 $m$ 代入代数式 $Y(x)$ 的 $x$ 中，使其穿越到现实世界并汇合。于是，就像数学魔法一样，“$X^2$ 和 $Y^2$ 的余数相同” 的状态就严密地完成了！

剩下的就如第1章所述，只要计算 $X - Y$ 和 $N$ 的最大公约数，坚不可摧的RSA密码就会轰然崩塌，秘密的质数就会显露出来。

结语：数学永无止境

你可能会想：“太好了，用 GNFS 就能破解任何密码了吧！” 但是，RSA 密码也没有认输。目前互联网上使用的是被称为“RSA-2048（约 617 位）”的怪物般的巨大数字。

不管 GNFS 作为人类最强算法有多厉害，据说仅仅是解开 270 位数（RSA-270），即使把全世界的计算机连接起来，也需要几千年、几万年。就目前而言，我们的 LINE 和银行数据是安全的。

然而，如果出现了 “无论多巨大的数字，都能瞬间找到 $X$ 和 $Y$ 的魔法”，那会怎么样呢？其实，最接近这种魔法的存在就是目前正在开发中的 “量子计算机（Shor 算法）”。在数学上已经证明，如果利用量子力学的波动性质，就能无视麻烦的卡片收集拼图，一击命中答案。

制造密码的人（防御）与制造破解密码算法的人（攻击）之间无止境的智慧较量。当你知道初中学到的“质因数分解”和“代数式”，其实是活跃在世界安全最前线激烈交锋的武器时，是不是觉得数学课稍微变得有趣了一点呢？

发现未来最强算法的，也许就是正在读这篇文章的你！

(※本文是为了向初中生概念化地展示密码破译的数学魅力而写的。实际的 GNFS 使用了代数域的理想类群、同态映射等高级大学数学知识进行严密计算。)

通俗易懂地讲解开普勒猜想

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

通俗易懂地讲解开普勒猜想！〜如何将西瓜装得最满〜

大家好，我是 kenji！

今天我想尽可能通俗易懂地为大家解释一个名字听起来有点难的数学话题——“开普勒猜想”。

乍一看，这是一个非常硬核的话题，但实际上它也是一个与我们息息相关的问题：“如何将西瓜紧紧地装进箱子里？”。它不仅与便利店的冰箱有关，也与货物的堆叠方式有关。

而且，在数学界，这是一个 400多年来都无法被证明 的充满浪漫色彩的故事。

那么，我们开始吧！

开普勒到底是谁？

首先，“开普勒猜想”中的“开普勒”是谁呢？

他是德国天文学家、数学家 约翰内斯·开普勒（Johannes Kepler）。

这个人非常了不起。例如，发现行星轨道是椭圆形的就是他。这在今天已经是常识，但在当时（1600年左右），连日心说都还没有被完全相信。

伽利略＝观测天才
开普勒＝用数学公式解释宇宙的天才
牛顿＝将其理论总结为物理定律的超级天才

大致是这样的定位，开普勒可以说是“用数学公式讲述宇宙”的先驱。

然后，有一天他提出了这样一个问题。

什么是开普勒猜想？

“开普勒猜想”简单来说，就是这样一个问题。

当将同样大小的球（西瓜或橙子）装进箱子时，哪种排列方式能装得最满？

就是这样一个问题。

开普勒在1600年代的猜想是：

像蔬果店里摆放橙子那样，堆成类似三角形的方式是不是效率最高？

就是这样。

用数学的话来说，这被称为“最密堆积问题（Sphere Packing Problem）”，即寻找将球体最密集地填满空间的方法。

开普勒猜测，一种被称为“面心立方结构（FCC）”的排列方式（就像把西瓜堆成三角形那样）是效率最高的。

对于这个猜测，大家都觉得“确实看起来是这样～”，但在数学上要证明“绝对是这个最好！”却极其困难。

证明花了400年！？！

那么，它实际上是什么时候被证明的呢……

竟然是在 1998年到2005年左右。也就是说，近400年里没有一个人能证明。太不可思议了。

而且，证明它的是美国数学家 托马斯·黑尔斯（Thomas Hales）。

他认为仅靠手工计算是不可能的，于是 使用计算机进行了证明。但是，由于那个证明过于复杂，导致了人类无法完全检查！这样的问题发生了。

因此，在数学界也引发了“那么，用计算机证明的真的可以相信吗？”的巨大争议。

最终，包含计算机在内的“经过了严格验证哦！”的证明（正式名称为“形式化证明”）在 2014年 才宣告完成。

也就是说，从开普勒的直觉到被 证明是正确的，花了400多年的时间。太浪漫了。

在现实生活中也有极其广泛的应用

你可能会以为“如何排列球体”只是数学宅男的话题，但其实它非常实用。

在便利店的冰箱里高效地摆放饮料
将罐头堆放在运输托盘上时
也应用于通信（如数字信号压缩等）
还用于3D打印机和晶体结构的设计

等等，这实际上是一个在我们生活背后被大量使用的理论。

总结：人类的直觉真厉害

那么，总结一下。

开普勒猜想 ＝如何将球装得最满？的问题
开普勒先生 ＝发现行星轨道的数学家、天文学家
提出猜想是在1600年代！但被证明是在2000年代！
在现实生活中也有非常多的应用！

最有趣的一点是， “蔬果店老板凭感觉堆叠的方式，在数学上也是最强的”。

也就是说，人类的直觉真厉害。而且，证明这一点有时需要花上400年，这真是一个非常浪漫的故事对吧。

感兴趣的朋友，请务必去搜索一下“托马斯·黑尔斯”、“形式化证明”、“Sphere Packing”。深入了解会发现非常有趣。

那么，下次见！

[PR]

立即购买

考拉兹猜想

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

“任何数字最终都会变成1”是真的吗？——玩转考拉兹猜想

大家好！我是kenji。

突然问一下，如果你听说“任何数字最终都会变成1的规则”，会不会觉得有些不可思议？

比如19，或者87，甚至1000000也是如此。按照特定的规则去处理数字，不知为何最后都会收敛到“1”。

像梦一样的故事，这就是 考拉兹猜想（Collatz Conjecture）。

考拉兹猜想究竟是什么？

首先介绍一下规则。

起点：选择任意一个 正整数
操作：
- 如果是偶数 → 减半（n → n / 2）
- 如果是奇数 → 乘以3再加1（n → 3n + 1）

一直重复这个过程，猜想认为 任何数字最终都会到达1。

比如，从 6 开始：

1

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

确实变成了“1”。欢迎回来！

用代码试试看：用Python写考拉兹猜想

好了，这种时候写代码测试最快！让我们用Python输出一下“考拉兹数列”。

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


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

# 例子：从19开始
print(collatz(19))

运行结果：

1

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

完美到达了1。虽然绕了不少远路，但最后还是顺利冲过终点！

顺便说一下，即使从 27 开始，也同样会到达1。

1

print(collatz(27))

运行结果：

1
2
3
4
5
6
7
8


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

竟然花了111步！

而且，中途还有膨胀到9000以上的阶段。这真是绕了天大的远路才到达终点的模式啊。

那么，到底哪里厉害呢？

这个猜想的厉害之处在于，

虽然还没有被证明，但似乎不管用什么数字来算都会变成1

这一点。

诶？那1兆呢，1京呢……？

能想到这点的你很敏锐。实际上，用计算机已经验证到了“2的68次方”左右， 全部都到达了1。难以置信……。

但是，“全部都会这样”并没有在理论上被证明。这就是数学世界里的“未解决问题”。

考拉兹是谁？

读到这里，你肯定会想“考拉兹到底是谁？”吧。下面就好好介绍一下！

姓名：洛塔尔·考拉兹（Lothar Collatz）
国籍：德国
生卒年：1910年〜1990年
头衔：数学家（活跃于泛函分析和数论领域）

他在1937年提出了这个猜想，此后，在长达80多年的时间里，谁也没能证明，也没能推翻。

顺便一提，这个问题虽然如此简单，却又无比深奥，以至于连保罗·埃尔德什（超著名的数学家）都这样说过：

“数学还没有成熟到足以解决考拉兹猜想。”

也就是说，人类的数学水平可能还没赶上这个谜团……。

不需要“复杂的公式”

考拉兹猜想的美妙之处在于，任何人都能玩。

只要有纸和笔就能算。用Python写几行代码，就能自动测试。不仅如此，最顶尖的数学家们也在认真挑战它。

怎么样，是不是让人热血沸腾？

彩蛋：一次性测试的代码

这里也附上可以一次性测试多个数字的代码。

1
2
3


for n in range(1, 21):
 steps = collatz(n)
 print(f"{n}: {steps}（步数: {len(steps)-1}）")

这能一口气输出“1～20”的考拉兹数列。

结论：这个世界，果然很不可思议

这就是考拉兹猜想。

明明极其简单
却没人能证明
在数学界是个大难题

它就像是一个不可思议的集合体。

即使是编程初学者也能尝试，请务必玩玩看哦〜！

P≠NP猜想

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

概要

1

P类问题是指在确定性图灵机上，能够在多项式时间内判定的问题类别。而NP类问题是指，当给定一个“是”的证据（称为Witness）时，能够在多项式时间内验证该Witness正确性的问题类别。由于在多项式时间内可以判定的问题，也必定能在多项式时间内被验证，因此P⊆NP是显而易见的。但P是否为NP的真子集，目前尚不明确。尽管目前尚未得到证明，但大多数研究人员都相信P≠NP。这种认为P类问题与NP类问题不相等的猜想，就被称为“P≠NP猜想”。

参考网站 : https://daigakudenki.com/np-hard/

生成素数的C语言代码

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

以下是一个简单的C语言代码，用于生成指定范围内的素数。在这个例子中，我们列举出1到n之间的素数。

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


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

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

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

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

int main() {
 int n;
 printf("请输入生成素数范围的最大值: ");
 scanf("%d", &n);
 printf("1到%d的素数如下:\n", n);
 printPrimes(n);
 return 0;
}

这段代码的运行机制如下：

isPrime函数：判断给定的数是否为素数。出于效率考虑，首先检查是否能被2和3整除，然后步长为6进行后续检查。
printPrimes函数：输出指定范围内的素数。首先输出2，之后只检查奇数。
main函数：接收用户输入的范围最大值，并输出该范围内的素数。

编译并运行此代码后，将会显示指定范围内的素数。

Mathematica入门

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

Mathematica入门

解方程

1

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

输出

1

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

在整数范围内求方程的解

1

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

输出

1

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

解方程组

1

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

输出

1

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

解不等式

1

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

输出

1

x < 1 || x > 2

微分

1

D[x^2, x]

输出

1

2 x

积分

1

Integrate[x^2, x]

输出

1

x^3/3

求极限

1

Limit[1/x, x -> 0]

输出

1

Infinity

求级数

1

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

输出

1

π^2/6

创建矩阵

1

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

求矩阵乘积

1

m . m

输出

1

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

求逆矩阵

1

Inverse[m]

输出

1

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

求特征值与特征向量

1

Eigensystem[m]

输出

1

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

求向量的点积

1

{1, 2} . {3, 4}

输出

1

11

求向量的叉积

1

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

输出

1

{-3, 6, -3}

求向量的模（大小）

1

Norm[{1, 2, 3}]

输出

1

√14

求向量的夹角

1

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

输出

1

ArcCos[11/(√5 √25)]

求向量的投影

1

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

输出

1

{11/5, 22/5}

求向量的旋转

1

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

输出

1

{0, 1}

求向量的平移

1

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

输出

1

{4, 6}

求向量的缩放

1

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

输出

1

{2, 3}

求向量的反转（反射）

1

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

输出

1

{0, 0}

生成随机数

1

RandomReal[]

输出

1

0.123456

生成随机数（整数）

1

RandomInteger[]

输出

1

123456

生成随机数（指定范围）

1

RandomReal[{1, 10}]

输出

1

5.6789

生成随机数（整数、指定范围）

1

RandomInteger[{1, 10}]

输出

1

5

生成随机数（指定分布）

1

RandomVariate[NormalDistribution[0, 1]]

输出

1

0.123456

生成随机数（指定分布、指定数量）

1

RandomVariate[NormalDistribution[0, 1], 10]

输出

1

{0.123456, 0.234567, ..., 0.987654}

生成随机数（指定分布、指定数量、指定种子）

1
2


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

输出

1

{0.123456, 0.234567, ..., 0.987654}

对数组元素应用函数

1
2
3


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

输出

1

{1, 2, 3}

使用Lambda表达式定义函数

1
2


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

输出

1

9

复合函数

1
2
3
4


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

输出

1

16

引用上一次的计算结果

1

% + 1

输出

1

17

纯函数

1

(#+3)&[5]

输出

1

8

数组提取

1
2


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

输出

1

{2, 4}

什么是生日悖论

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

你知道生日悖论吗？

我来说一个有点不可思议的话题。你认为聚集多少人，“有相同生日的人的概率”才会变高呢？

例如，一年有365天，所以如果说“聚集23人，有人生日相同的概率在50%以上”……总觉得有点违反直觉吧。

但是这，真的是在50%以上。

为什么会发生这种事呢？

这种现象被称为“生日悖论”。虽然名字叫“悖论”，但有着严谨的数学理由。

设人数为“n”时，没有人生日相同的概率 可以用以下公式求出：

1

P(没有人生日相同) = 365/365 × 364/365 × 363/365 × ... × (365 - n + 1)/365

用1减去这个值，就能得出“有人生日相同的概率”。

看看结果……

人数	有相同生日的人的概率
10人	约11.7%
20人	约41.1%
23人	约50.7%（注意这里！）
30人	约70.6%
70人	竟然约99.9%！

也就是说，只需 23人，就有超过一半的概率有人生日相同。在学校的班级或者职场的会议中，似乎很容易就会出现这种情况呢。

总结：直觉与数学的偏差很有趣

“生日悖论”是一个我们的直觉与实际的数学概率产生偏差的有趣例子。了解这些，也许能在闲聊或问答中活跃气氛！

参考链接

生日悖论（Wikipedia）

蒙提霍尔问题

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

什么是蒙提霍尔问题

蒙提霍尔问题（Monty Hall problem）是源自美国电视节目《Let’s Make a Deal》中的一个游戏，问题如下：

前提条件：3扇门中只有1扇门后有奖品，其余2扇门后是没有奖品的。

参赛者在3扇门中选择1扇。
主持人在参赛者未选择的2扇门中，打开1扇没有奖品的门。
主持人询问参赛者是否要更换选择的门。

此时，问题是参赛者改变选择好，还是不改变选择好。

解法

蒙提霍尔问题的解法如下：

如果参赛者不改变最初选择的门
- 中奖概率：1/3
- 不中奖概率：2/3
主持人打开一扇没有奖品的门后
- 如果不改变选择，中奖概率：1/3（与1中的中奖概率相同）
- 如果改变选择，中奖概率：2/3（1中不中奖的概率）

因此，参赛者改变选择后中奖的概率更高。

参考

维基百科 Monty Hall problem

数学的未解决问题

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

数学的未解决问题

下面来介绍一些数学中的未解决问题。尽管问题本身非常简单，但仍有许多尚未被证明的问题。

完全数有无数个吗？

完全数是指除了自身以外的所有正约数之和等于其本身的自然数。例如：

6的约数有1、2、3，而1+2+3=6，因此它是完全数。
28的约数有1、2、4、7、14，而1+2+4+7+14=28，因此它是完全数。

目前只发现了51个完全数，虽然人们猜想它有无数个，但至今尚未被证明。

哥德巴赫猜想

哥德巴赫猜想是指任何大于2的偶数都可以表示为两个素数之和。（这里的素数是指除了1和自身之外没有其他约数的自然数。）

例如：

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

问题本身非常简单，但至今仍未被证明。

黎曼猜想

黎曼猜想是指黎曼ζ函数的零点仅限于负偶数以及实部为 1/2 的复数。

黎曼ζ函数是指，当$s$为复数、$n$为自然数时，由

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

所定义的函数$\zeta$。

数学的历史

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

古希腊三大作图问题

给定一个圆，作一个与该圆面积相等的正方形（化圆为方问题）
给定任意角，将其三等分（三等分角问题）
给定一个立方体，作一个体积为其两倍的立方体（倍立方体问题）

阿基米德螺线

在平面上，使射线OB绕定点O匀速旋转。设初始位置为OA，在其从OA开始旋转的同时，点P从O点出发，沿OB以恒定速度移动，此时点P所描绘的曲线即为阿基米德螺线。

帕普斯定理

摆线
尼科梅德斯蚌线
狄奥克莱斯蔓叶线
费马切线法
笛卡尔法线法

年表

年份	事件
约公元前3400年	苏美尔人使用黏土代币进行记账
约公元前3000年	埃及出现象形文字数学
约公元前2800年	印度河文明使用基于十进制的度量衡
约公元前2700年	埃及人使用绳子和毕达哥拉斯数确认角度
约公元前2500年	计算工具算盘被发现
约公元前2500年

参考

数学的历史

使用埃拉托斯特尼筛法列举1000以下的素数

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

什么是埃拉托斯特尼筛法

埃拉托斯特尼筛法是一种用于列举小于等于某个数值的所有素数的算法。算法非常简单，可以通过以下步骤实现：

创建一个包含 N 个元素的 bool 值数组，并将所有元素初始化为 true
将数组的第 0 个和第 1 个元素设为 false（因为 0 和 1 不是素数）
如果数组的第 2 个元素为 true，则将 2 作为素数输出
将数组中 $2^2$ 及以上的所有 2 的倍数位置的元素设为 false※
如果数组的第 3 个元素为 true，则将 3 作为素数输出
将数组中 $3^2$ 及以上的所有 3 的倍数位置的元素设为 false
对于第 4 个、第 5 个、……、第 N 个元素，重复相同的处理

※ 之所以将平方以上的元素作为 false 的目标，是因为小于平方的数已经被处理过（列举已完成）。

Rust 中的实现

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


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

稍微优化的版本

考虑到以下几点，我们进行稍微优化后的实现：

数组不使用 true 而是使用 false 进行初始化（这样更快）
2 的倍数不是素数，所以省略将 2 的倍数元素设为 false 的处理
不需要循环到 n，只需列举到 n 的平方根即可找出 n 以下的素数

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


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

参考

埃拉托斯特尼筛法

使用 Python (matplotlib.pyplot) 绘制图表的方法

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

所需条件

Google 账号

步骤

访问 https://colab.research.google.com/
选择“文件” -> “新建笔记本”
粘贴并运行以下代码

1
2
3
4
5
6
7


import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 2*np.pi, 500)
plt.plot(x, np.sin(x), label="sin curve")
plt.plot(x, np.cos(x), label="cos curve")
plt.legend() # 显示图例
plt.show()

运行结果

参考资料

matplotlib.pyplot — Matplotlib 3.5.3 documentation

在hugo中启用KaTeX（类似LaTeX的数学公式显示）的方法

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

什么是KaTeX

KaTeX是一个在HTML中显示类似LaTeX的数学公式的JavaScript库。

具体来说，可以显示如下所示的数学公式。

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

似乎还有其他类似LaTeX的数学公式显示库，但KaTeX以简单和高速而闻名。

在hugo中的导入方法

在hugo的文件夹层级中新建layouts/partials/math.html。

内容请参考如下所示。

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


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

接下来，在现有的文件layouts/partials/extend_head.html中添加以下代码。

1
2
3


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

这样使用KaTeX的准备工作就完成了。

通过在页面的front matter中添加math: true，可以启用KaTeX。

之后只需在页面文章的正文中，以类似LaTeX的方式编写数学公式即可。

1

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

如上编写后，将显示如下。

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

参考

用 Mathematica 解决旅行商问题

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

用 Mathematica 解决旅行商问题

问题

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

解法

1

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

使用 SparseArray 函数创建一个矩阵。每个元素代表其所在行和列对应的城市之间的距离。例如，第一个元素 {1,2}->10 表示城市 1 和城市 2 之间的距离是 10。倒数第二个元素 {9,9} 表示矩阵的大小，而最后一个元素 Infinity 表示未指定的城市之间的道路长度为无穷大，也就是说没有直接的道路。

1

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

使用 FindShortestTour 函数，可以轻松解决旅行商问题。{1,2,3,4,5,6,7,8,9} 代表城市编号。DistanceFunction->(d[[#1,#2]]&) 传入了表示城市间距离的矩阵 d。

输出

1

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

输出是最短距离以及此时的巡回路线。最短距离为 137，巡回路线为 1→2→5→9→8→7→6→3→4→1。按照 ABC 顺序转换为 A, B, E, I, H, G, F, C, D。

喜欢的数学公式

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

威尔逊定理

当 $p$ 为素数时，$(p−1)!≡−1 \pmod p$ 成立

欧拉公式

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

费马大定理

对于 $n≥3$ 的整数 $n$，不存在满足 $x^n+y^n=z^n$ 的正整数组 $x,y,z$

巴塞尔问题

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

欧拉素数生成公式

当 $n$ 为 $0$ 到 $39$ 之间的整数时，$n^2+n+41$ 的值全部为素数

【公式完全解析】经典最强“GNFS”为何败给量子算法？因数分解的范式转变

Mon, 01 Jan 0001 00:00:00 +0000

现代互联网社会中的信息安全，是由以RSA密码为首的公开密钥密码体制来保障的。RSA密码安全性的依据依赖于这样一个事实：“对巨大的合数进行因数分解在计算上是极其困难的”。

本文将为您剖析经典计算机中最强的因数分解算法——“普通数域筛选法”（General Number Field Sieve, GNFS）的数学机制，并通过公式和概念图深入探讨它为何会被彼得·肖尔发现的 “Shor算法” 彻底击败，揭示这场范式转变。

1. 经典计算中的因数分解方法：从费马因数分解法的发展

因数分解问题是指：对于给定的合数 $N$，找到素数 $p, q$ 使得 $N = p \times q$ 的问题。

基本的思路归结为寻找满足以下同余式的非平凡的 $x, y$：

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

对其进行变形，得到：

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

在此，如果 $x \not\equiv \pm y \pmod N$，则通过计算 $\gcd(x-y, N)$ 或 $\gcd(x+y, N)$，就可以得到 $N$ 的非平凡因子。这一事实构成了包括GNFS在内的现代因数分解算法的基础。

2. 经典最强算法：“普通数域筛选法”（GNFS）的深渊

“GNFS” 是目前已知针对经典计算机的最快因数分解算法。其时间复杂度需要亚指数级（Sub-exponential）的时间。

GNFS的计算复杂度

设数字 $N$ 的位数为 $b = \log_2 N$，GNFS的计算复杂度可以表示为：

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

从这个公式可以看出，计算复杂度并不是多项式时间，而是比指数函数稍慢的 “亚指数时间”。尽管如此，随着位数的增加，计算时间仍会呈天文数字般增长。

GNFS的数学机制

GNFS主要由四个步骤组成：

多项式选择 (Polynomial Selection)
筛选 (Sieving)
矩阵化简 (Matrix Reduction)
平方根计算 (Square Root)

2.1. 多项式选择与代数数域

首先，选择以整数为系数的不可约多项式 $f(x)$ 和 $g(x)$。它们被设定为在模 $N$ 下具有公共根 $m$。即：

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

通常，$g(x)$ 被选择为一次多项式 $g(x) = x - m$。设 $f(x)$ 的根为 $\alpha$，则构造出一个名为 $\mathbb{Q}(\alpha)$ 的 “代数数域”（Number Field）。通过同态映射 $\phi: \alpha \mapsto m$，比较 $\mathbb{Q}(\alpha)$ 环中的运算与普通整数环 $\mathbb{Z}$ 中的运算。

2.2. 筛选 (Sieving)

接着，寻找大量互素的整数对 $(a, b)$。目的是找到满足以下两个值分别为 “B-smooth”（仅由较小素因子组成）的整数对：

$a - bm$ （整数环上的值）
$b^d f(a/b)$ （对应代数数域上的范数 $N(a - b\alpha)$）

在这里采用被称为 “筛选”（Sieve）的高效搜索方法。这使得我们能够从庞大的候选集中高效提取满足条件的 $(a, b)$ 对。

2.3. 矩阵化简 (Linear Algebra over GF(2))

由收集到的整数对 $(a, b)$ 构造指数向量，并在 $\mathbb{F}_2$ （仅包含0和1的域）上求解巨大稀疏矩阵的左零空间。

找到向量 $v$ 作为解，使得关系式 $ \prod (a_i - b_i m) $ 和 $ \prod (a_i - b_i \alpha) $ 都成为平方元。这无异于求解如下线性方程组：

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

在这里，使用了如分块Lanczos法（Block Lanczos Algorithm）和分块Wiedemann法（Block Wiedemann Algorithm）等高级数值计算算法。

2.4. 平方根计算

最后，在代数数域和整数环上同时取平方根，导出 $x^2 \equiv y^2 \pmod N$ 的关系式。然后计算 $\gcd(x-y, N)$ 从而得到因子。

3. 量子计算的突破：“Shor算法”

相较于GNFS需要亚指数级时间，彼得·肖尔在1994年发表的 “Shor算法”，利用量子计算机可以在 “多项式时间” 内解决这一问题。

Shor算法的计算复杂度

假设量子比特数为 $O(\log N)$，时间复杂度如下：

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

这意味着它不会随比特数产生指数级的爆炸。即使是那些对于 “经典计算” 而言计算量超过宇宙寿命的巨大合数，在 “量子计算” 下也能在几小时到几天内破解，这是一个惊人的结果。

Shor算法全貌：归结为寻找周期问题

Shor算法巧妙地将因数分解问题归结为 “寻找周期问题”。

选取与 $N$ 互素的随机整数 $a$（$1 < a < N$）。
定义函数 $f(x) = a^x \bmod N$。
找到 $f(x)$ 的周期 $r$，即满足 $a^r \equiv 1 \pmod N$ 的最小正整数 $r$。
如果 $r$ 为偶数，则检查 $a^{r/2} \not\equiv -1 \pmod N$ 是否成立，计算 $\gcd(a^{r/2} \pm 1, N)$ 以获得素因子。

这个步骤3中 “周期的寻找 $r$” 正是经典计算机需要指数级时间的瓶颈，但量子计算机利用 “量子叠加” 和 “量子傅里叶变换”（QFT），可以瞬间解决这个问题。

4. 量子傅里叶变换（QFT）与周期提取

让我们用公式详细看看Shor算法的核心——量子状态的操作。

4.1. 量子叠加的生成

首先，准备两个量子寄存器。寄存器1保持输入 $x$ 的叠加态，寄存器2保持函数的计算结果 $f(x)$。对初始状态 $|0\rangle |0\rangle$ 应用阿达马变换（Hadamard Transform），创造出所有可能 $x$ 的叠加。

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

（其中 $Q$ 是满足 $N^2 \le Q < 2N^2$ 的2的幂）

接着，利用量子预言机 $U_f$ 计算 $f(x) = a^x \bmod N$ 并存入寄存器2。

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

假设现在测量了寄存器2（实际上即使不测量，数学结构也是相同的）。如果观测到某个值 $y = a^{x_0} \bmod N$，寄存器1的状态就会坍缩到所有使 $f(x) = y$ 成立的 $x$ 的叠加。设周期为 $r$，那么这样的 $x$ 将是 $x_0, x_0 + r, x_0 + 2r, \dots$。

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

（其中 $M \approx Q/r$ 是项数）

这个状态内含了周期 $r$ 的信息，但直接测量只能得到随机的 $x_0 + kr$，无法得知周期 $r$。这时QFT便派上用场了。

4.2. 应用量子傅里叶变换 (Quantum Fourier Transform)

QFT是对量子状态的振幅进行离散傅里叶变换的操作。QFT对状态 $|x\rangle$ 的作用定义如下：

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

将此应用于 $|\psi_3\rangle$，会发生相位干涉（量子干涉）。

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

展开此式的和：

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

这部分便显现出来。这个等比数列的和，只有当 $ry/Q$ 接近整数时才会增强（Constructive Interference），在其他情况下则会相互抵消（Destructive Interference）。

因此，以高概率被测量到的状态 $|y\rangle$ 将是满足以下条件的整数 $y$：

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

（$c$ 为某个整数）

4.3. 通过连分数展开确定周期

通过测量得到 $y$ 后，使用经典计算机对 $y/Q$ 进行 “连分数展开”（Continued Fraction Expansion）。由此计算出 $y/Q$ 的近似分数 $c/r$，从而可以高效地从分母中提取出周期 $r$ 的候选值。

5. 概念模型比较与范式转变

为了直观理解GNFS和Shor算法的区别，下面展示使用Mermaid语法的概念图。

基于量子电路的Shor算法概念图

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


graph TD
 A[初始状态: 0...0] --> B[阿达马变换实现全状态叠加]
 B --> C[模幂运算 a^x mod N]
 C -->|量子纠缠| D[坍缩到具有周期性的状态]
 D --> E[量子傅里叶变换 QFT]
 E -->|干涉概率放大| F[测量: 得到y]
 F --> G[经典处理: 连分数展开]
 G --> H[找到周期 r]
 H --> I[算出N的素因子]

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

范式转变的本质

GNFS采取了 “在数学空间（代数数域）中寻找关系式” 的方法。然而，搜索空间随位数呈指数级扩展，因此在经典计算机的计算能力（即使包含并行化）下，当密钥长度超过2048位等时，实际上是无法解密的。

另一方面，Shor算法利用了 “量子干涉的波特性”。同时评估处于叠加态的所有计算路径，通过QFT抵消（减弱）不需要的答案，仅放大（增强）作为正确答案的周期概率振幅。由此实现了非遍历空间，而是 “让正确答案浮现” 的完全不同维度的途径。

6. 总结

本文深入比较了经典极限巅峰的 “GNFS” 和展现量子计算力量的 “Shor算法”，探讨了各自的数学背景和算法结构。

相较于GNFS倾尽多项式选择或巨大矩阵计算等数学技巧将计算复杂度降至亚指数时间，Shor算法将量子力学的基本原理——叠加与干涉与数学工具（QFT）融合，一举实现了向多项式时间的突破。

目前，能够以实用规模（数千个量子比特）运行Shor算法的容错量子计算机（FTQC）尚不存在。然而，正是这种数学与理论范式转变的存在，构成了当今世界急切向抗量子密码（PQC: Post-Quantum Cryptography）过渡的最大理由。

数学 on kenji.blog

【完全解剖】使用C++实现并理解最强密码破解算法「GNFS」

【完全解剖】使用C++实现并理解最强密码破解算法「GNFS」

1. GNFS 最尖端逻辑框架（完整源代码）

2. GNFS的最终目的： $X^2 \equiv Y^2 \pmod N$

3. Phase 1: 多项式选择（Polynomial Selection）

4. Phase 2: 特殊 $q$ 格筛选法（Special-q Lattice Sieving）

5. Phase 3: 过滤（Filtering）

6. Phase 4: GF(2) 上的线性代数（Block Wiedemann法）

7. Phase 5: 代数平方根（Algebraic Square Root）与密码的崩溃

结语

一般数域筛法（GNFS）的真正数学结构

一般数域筛法（GNFS）的真正数学结构

第一阶段：连接世界的“同态映射（Homomorphism）”

1. 多项式的选择与根的定义

2. 环（Ring）与同态映射的构建

第二阶段：质因数分解的崩溃与“理想（Ideal）”的诞生

库默尔与戴德金的拯救：“理想”

第三阶段：范数（Norm）与双筛法（Sieve）

第四阶段：两道“障碍”的阻挡与理想类群

障碍①：理想类群（Ideal Class Group）的壁垒

障碍②：单位群（Unit Group）的壁垒

第五阶段：阿德曼的魔法“二次剩余特征（Quadratic Characters）”

最终阶段：世界的融合与密码的崩溃

破解互联网密码的人类最强数学“一般数域筛选法（GNFS）”是什么？

破解互联网密码的人类最强数学“一般数域筛选法（GNFS）”是什么？

第1章：密码破译的目标是“初三的公式”

为什么“余数相同”就能解开密码？

第2章：如何寻找X和Y？“收集质数卡片的拼图”

Step 1：用筛子只收集沙金（平滑数）

Step 2：全部变成“偶数个”的拼图

第3章：阻挡在前的绝望之墙

第4章：人类最强的点子，创造“两个世界”

代数式的魔法

在两个世界同时寻找沙金

密码终于被破译的瞬间

结语：数学永无止境

通俗易懂地讲解开普勒猜想

通俗易懂地讲解开普勒猜想！〜如何将西瓜装得最满〜

开普勒到底是谁？

什么是开普勒猜想？

证明花了400年！？！

在现实生活中也有极其广泛的应用

总结：人类的直觉真厉害

考拉兹猜想

“任何数字最终都会变成1”是真的吗？——玩转考拉兹猜想

考拉兹猜想究竟是什么？

用代码试试看：用Python写考拉兹猜想

那么，到底哪里厉害呢？

考拉兹是谁？

不需要“复杂的公式”

彩蛋：一次性测试的代码

结论：这个世界，果然很不可思议

推荐链接（面向感兴趣的人）

P≠NP猜想

概要

生成素数的C语言代码

Mathematica入门

Mathematica入门

解方程

在整数范围内求方程的解

解方程组

解不等式

微分

积分

求极限

求级数

创建矩阵

求矩阵乘积

求逆矩阵

求特征值与特征向量

求向量的点积

求向量的叉积

求向量的模（大小）

求向量的夹角

求向量的投影

求向量的旋转

求向量的平移

求向量的缩放

求向量的反转（反射）