數學 on kenji.blog

【完全解剖】最強密碼破解演算法「GNFS」C++實作與理解

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

【完全解剖】最強密碼破解演算法「GNFS」C++實作與理解

支撐現代網際網路基礎的「RSA密碼學」，其堅固性仰賴於一個數學信念：「在目前的電腦技術下，要對巨大的合成數進行質因數分解實際上是不可能的」。

然而，人類從未放棄。目前在古典電腦（非量子電腦的一般電腦）上，存在著用於進行巨大質因數分解的 人類最強、最尖端的演算法 。那就是 「普通數體篩法（GNFS：General Number Field Sieve）」 。

在本篇文章中，我們將完全公開這個 GNFS 最尖端計算邏輯的 C++ 實作程式碼（使用 Boost 函式庫的多精度整數 boost::multiprecision 進行嚴格建模），並徹底解說其背後「代數整數論」的深淵。

請務必與原始碼一起，盡情品味數學的神秘以及用電腦科學暴力屈服它的力量。

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*...) 上，
 // 執行將快取效率提升到極限的篩法 (Sieve)。

 // 為了展示，加入一個虛擬的 Relation (關係)
 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 (刪除只出現過一次的質數的 Relation)
 // 2. Clique merging (為使稀疏矩陣變密集而合併 Relation)
 // 實際上會使用 Union-Find 等演算法，將數億行的矩陣壓縮到數百萬行。
 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;
 // 反覆進行稀疏矩陣 (Sparse Matrix) 與向量的乘法運算，
 // 找到多個滿足 M * x = 0 mod 2 的解向量 (核, Kernel)。

 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's method 等)
 // 求出巨大代數體 O_K 的元素 gamma，並透過同態映射 phi 映射到現實世界中
 // Y = phi(gamma) mod N
 cpp_int Y = 1;

 // 為迴避理想類群 (Ideal Class Group) 與單位群 (Unit Group) 的障礙 (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;

 // RSA-270 等，想要質因數分解的巨大合成數 N
 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 的晶格上，
 // 執行將快取效率提升到極限的篩法 (Sieve)。
 // ...
 }
};

準備好兩個世界後，接下來進入在兩個世界中尋找「平滑數（僅由小質數構成的數）」的步驟。產生無數個整數對 $(a, b)$，並計算以下兩個值：

有理側的值 ： $a - bm$
代數側的範數 (Norm) ： $b^d f(a/b)$

GNFS 的目標是收集數千萬至數億個 「有理側與代數側的值，兩者都能完全被小質因數分解的數對（Relation：關係）」 。

早期的 GNFS 使用「直線篩法（Line Sieve）」，將 $(a, b)$ 排列在 $xy$ 平面上，從頭開始依序用質數去除。但這種方法會造成記憶體到處存取而頻繁發生快取未命中（Cache Miss），這是一個非常慢的弱點。

因此，現在最尖端的程式碼中使用了 「特殊 $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 (刪除只出現過一次的質數的 Relation)
 // 2. Clique merging (為使稀疏矩陣變密集而合併 Relation)
 }
};

在 Phase 2 中，全世界的電腦花費數個月收集了數億個 Relation。然而，如果直接將這些資料丟進下一個「解聯立方程式的步驟（矩陣計算）」中，超級電腦的記憶體也會被撐爆。

因此，會進行被稱為 Filtering（過濾） 的矩陣超壓縮過程。

Singleton removal（奇異點清除） 假設某個巨大的質數 $p$，在數億個 Relation 中「只出現了一次」。我們的目標是「讓所有質數的指數都變成偶數（2 的倍數）」，所以只出現一次的質數絕對不可能變成偶數。因此，包含該質數的 Relation 會立即被視為「無用的垃圾」而刪除（清除）。這個連鎖反應發生後，原本數億行的資料就會不斷被削減。
Clique merging（派系合併） 進一步地，將共享特定質數的 Relation 互相相乘（相加），在減少行數的同時，將稀疏（空洞）的矩陣壓縮成更密集的狀態（使用類似圖論中派系搜尋的手法）。

透過這個最佳化，巨大的稀疏矩陣將被戲劇性地壓縮至可計算的大小。

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) {
 // 反覆進行稀疏矩陣 (Sparse Matrix) 與向量的乘法運算，
 // 找到多個滿足 M * x = 0 mod 2 的解向量 (核, Kernel)。
 }
};

終於來到了謎題的核心。將收集到的 Relation 相乘，尋找 「所有質因數的指數都變成偶數的組合」 。

這在數學上，等同於使用一個以各質數指數的「偶數・奇數（亦即 0 或 1）」為元素的巨大矩陣 $M$，以及一個表示要使用哪些 Relation 的向量 $x$，來求解滿足 $M \cdot x \equiv 0 \pmod 2$ 的解向量 $x$ （零空間・核，Nullspace / Kernel）。

這需要解開數百萬行 × 數百萬列這種龐大尺寸矩陣的聯立方程式。若使用一般的基斯消去法（高斯消去法），計算複雜度將達到 $O(N^3)$，就算到宇宙毀滅也算不完。

因此，最尖端的實作採用了 「Block Wiedemann（區塊・維德曼）法」 。這是一種克雷洛夫子空間法（Krylov Subspace Method），利用矩陣 $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 的矩陣計算，我們獲得了「相乘後所有質因數皆為偶數次方的 Relation 集合 $S$」。藉此，我們可以在有理側與代數側這兩個世界中，各自建構出「平方（2 次方）」。

有理側只是單純的整數乘法，所以計算平方根 $V$ 非常容易。

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

然而，真正的地獄在「代數側」。 在代數體的世界 $\mathbb{Z}[\alpha]$ 中，質因數分解的唯一性並不成立，因此我們一直使用理想（Ideal）來進行計算。矩陣計算所保證的 只有「成為理想的平方」，並不能保證成為「元素的平方（$\gamma^2$）」 。

這裡會遇到被稱為「理想類群的障礙」與「單位群的障礙」，這是代數整數論中非常巨大的高牆。 GNFS 為了打破這面牆，使用了被稱為 「二次剩餘特徵（Quadratic Characters）」 的魔法。在 Phase 4 的矩陣中，事先偷偷加入針對幾十個特殊質理想的二次剩餘（勒讓德符號）序列。這樣一來，找到的集合 $S$ 就有極大的機率能避開障礙，順利形成「真正元素的平方 $\gamma^2$」。

求取 $\gamma$ 的工作（代數平方根），是使用 Montgomery 法等極其複雜的演算法來計算的。

最終，將代數側的平方根 $\gamma$，透過環同態映射 $\phi$ 瞬移回現實世界（將 $x$ 代入 $m$），得到 $Y$。將有理側的 $V$ 直接當作 $X$，我們夢寐以求的絕對等式終於完成了。

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

剩下的就只有計算 $\gcd(X-Y, N)$ 而已。0.001 秒的處理一閃而過，當非平凡的因數印在螢幕上的那一刻，號稱堅不可摧的 RSA 密碼便徹底崩潰。

結語

GNFS 不僅僅是一種程式設計的技巧。它是用超級電腦的分散式架構與快取最佳化等「極致的工程學」，去折服抽象代數學、環論、理想類群等「純數學深淵」的人類智慧結晶。

我們不經意傳送的聊天訊息或信用卡資訊，就是建立在這種天文數字般的數學攻防之上受到保護的。

希望透過這個 C++ 框架，能讓各位感受到最尖端密碼破解演算法背後的「數學與計算機的浪漫」。

一般數域篩法（GNFS）的真正數學結構

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

一般數域篩法（GNFS）的真正數學結構

GNFS 的終極目標是找到 $X, Y$，使得 $X^2 \equiv Y^2 \pmod N$。為了達成這個目標，數學家們在 「現實的整數世界」 與 「代數體世界」 之間架起了一座橋樑。那座橋樑正是「同態映射」。

第一階段：連結世界的「同態映射（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$ 的整數構成的同餘（Modulo）世界。

在這裡，我們定義一個從世界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$ 該上場了。我們利用 $\phi$（將 $\alpha$ 代入為 $m$ 的映射），將世界A的元素 $\gamma$ 傳送到世界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$，有 ** 50%（二分之一） ** 的數學機率，會分開進入不同的房間： ** 「$p$ 進入 $(X - Y)$ 的房間」和「$q$ 進入 $(X + Y)$ 的房間」 ** 。

在只有質數 $p$ 進入 $(X - Y)$ 房間的狀態下，讓我們計算 $(X - Y)$ 和 $N$ 的 ** 「最大公因數（共通的最大零件）」 ** 。

$(X - Y)$ 的內容＝ $p \times$ 某個數字
$N$ 的內容＝ $p \times q$ 共通的零件只有 ** 「$p$」 ** ！

也就是說，在計算出最大公因數的瞬間，隱藏的質數 $p$ 就會掉出來，密碼就被完全破解了。（※最大公因數只要使用「輾轉相除法」，用手機也能瞬間計算出來）

** 【小專欄：為什麼是 2 次方？3 次方或 2 倍不行嗎？】 **

如果是「$2X - 2Y$」會變成 $2(X - Y)$，因為只有一個房間，所以無法將質數分開。如果是「$X^3 - Y^3$」，房間的大小會變得不平衡，計算會變得不必要的繁重。為了將質數漂亮地分開到兩個房間，「2 次方」是成本效益最高的。

第 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$ ** 這個算式（裏世界）。

這個算式有趣的地方在於，它具有 ** 「只要將字母 $x$ 代入 $m$（在上面的例子中是 4），隨時都能瞬間移動回到現實數字 $N$」 ** 的特性。

在兩個世界中同時尋找沙金

GNFS 製造出許多隨機的整數對 $(a, b)$，並同時進行以下兩個計算：

** 現實世界 ** ： $a - b \times m$
** 代數式的世界 ** ：依照代數式規則計算 $a - b \times x$ 的值

藉由將問題分成兩個世界，處理的數字大小會戲劇性地變小（變輕）。這就像是把巨大的岩石劈成兩半，變成容易處理的石塊一樣的概念。

然後，我們用篩子過濾，只收集那些在 ** 「現實世界和代數式的世界中，兩者都是『只由小質數組成（沙金）』」 ** 的奇蹟整數對 $(a, b)$。這就是「數體篩法」名稱的由來。

密碼終於被破解的瞬間

當從兩個世界收集到數千萬張「沙金卡片」後，就會使用超級電腦的巨大矩陣計算，找出在第 2 章做過的「質數個數全部變成偶數的組合」。

找到組合後，

將現實世界中產生的平方數設為 ** $X^2$ **
將代數式世界中產生的平方算式設為 ** $Y(x)^2$ **

最後，將代數式 $Y(x)$ 中的 $x$ 代入 $m$，使其瞬間移動到現實世界並會合。這樣一來，宛如數學魔法般， ** 「$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）」 ，這是一個尋找在空間中最密實地鋪滿球的方法的問題。

克卜勒猜想，被稱為 「面心立方結構（FCC）」 的排列方式（就像將西瓜堆成三角形那樣）是最有效率的。

大家雖然都覺得「確實看起來是這樣～」，但是在數學上要證明「這絕對是最好的！」卻非常困難。

證明竟然花了 400 年！？！

那麼，它真正被證明是什麼時候呢……

竟然是 1998年〜2005年左右 。也就是說，將近 400 年都沒有人能證明出來 。太不可思議了。

而且，證明它的是一位名叫 托馬斯·黑爾斯（Thomas Hales） 的美國數學家。

這個人判斷只靠手算是不可能的，因此 使用了電腦進行證明 。然而，由於該證明過於複雜，導致人類無法好好檢查！這引發了一個問題。

於是，在數學界也引發了一場大爭論：「那麼，用電腦證明的結果真的可以相信嗎？」。

結果，「包含電腦在內，我已經嚴格驗證過了！」的證明（正式稱為「形式化證明」）是在 2014 年 完成的。

也就是說，直到證明克卜勒的直覺是正確的，花了超過 400 年 。真是太浪漫了。

在實際生活中也被廣泛應用

你可能會認為「球該怎麼排列」只是數學宅男的話題，但實際上它非常實用。

在便利商店的冰箱裡有效率地擺放飲料
將罐頭堆疊在運輸托盤上時
也被應用於通訊（例如數位訊號的壓縮）
用於 3D 列印機或晶體結構的設計

等等，這其實是我們生活中背後被大量使用的理論。

總結：人類的直覺很了不起

那麼，我們來總結一下。

克卜勒猜想 ＝如何將球裝得最密實的問題
克卜勒先生 ＝發現行星軌道的數學兼天文學家
是在 1600 年代猜測的！但被證明是在 2000 年代！
在實際生活中也被廣泛應用！

而最有趣的一點是， 「蔬果店憑直覺堆疊的方法，在數學上也是最強的」 。

也就是說，人類的直覺很了不起 。而且，證明這一點可能需要花上 400 年 ，這真的是一個充滿浪漫色彩的故事呢。

如果你對此感興趣，請務必搜尋看看「托馬斯·黑爾斯」、「形式化證明」、「Sphere Packing」。深入挖掘的話會非常有趣。

那麼下次見！

[PR]

今すぐ購入

P≠NP猜想

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

概要

1

P類別是在確定性圖靈機上可以在多項式時間內判定的一類問題，而NP類別是當給定一個結果為Yes的證據（稱為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

什麼是蒙提霍爾問題

蒙提霍爾問題是美國電視節目「Let’s Make a Deal」中進行的一個遊戲問題，內容如下：

前提條件：3 扇門中有一扇後面有獎品，其餘 2 扇門後面是空的（銘謝惠顧）。

參賽者從 3 扇門中選擇一扇。
主持人在參賽者未選擇的 2 扇門中，打開一扇沒有獎品的門。
詢問參賽者是否要改變選擇的門。

此問題在於探討參賽者換門比較好，還是不換門比較好。

解法

蒙提霍爾問題的解法如下：

參賽者不改變最初選擇的門
- 中獎機率：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，點 P 從 O 出發，並沿著 OB 以等速移動，此時點 P 所描繪出的曲線即為阿基米德螺線。

帕普斯定理

擺線 (Cycloid)
尼科梅迪斯蚌線 (Conchoid of Nicomedes)
狄奧克勒斯蔓葉線 (Cissoid of Diocles)
費馬切線法
笛卡兒法線法

年表

年份	事件
約公元前 3400 年	蘇美爾人使用黏土代幣進行計數
約公元前 3000 年	埃及出現聖書體數學
約公元前 2800 年	印度河流域文明使用十進制度量衡
約公元前 2700 年	埃及人使用繩索和畢氏三元數確認角度
約公元前 2500 年	發現用於計算的工具——算盤
約公元前 2500 年

參考資料

數學的歷史

如何使用埃拉托斯特尼篩法列出1000以下的質數

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

什麼是埃拉托斯特尼篩法

埃拉托斯特尼篩法是一種用來找出一定範圍內所有質數的演算法。演算法很簡單，可以透過以下步驟實現：

建立一個包含 N 個元素的布林值陣列，並將所有元素初始化為 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;
 }
 }
 }
}

稍微最佳化版本

考慮到以下幾點，我們進行稍微最佳化的實作：

將陣列初始化為 false 而不是 true（這樣速度更快）。
因為 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$，不存在滿足 $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）的數學機制，並透過數學公式與概念圖，深入探討為何它會被彼得·秀爾（Peter Shor）所發現的 「Shor演算法」 完全擊敗，徹底剖析這場典範轉移。

1. 古典計算中質因數分解的策略：從費馬質因數分解法的發展

質因數分解問題，是對於給定的合成數 $N$，找出滿足 $N = p \times q$ 的質數 $p, 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)$。它們被設定為在 modulo $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的體）上求出巨大稀疏矩陣的左零空間。

為了讓關係式 $ \prod (a_i - b_i m) $ 與 $ \prod (a_i - b_i \alpha) $ 分別成為平方元素，我們找出向量 $v$ 作為解。這無非就是解以下的線性方程組：

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

在此階段，會活用如區塊蘭佐斯法（Block Lanczos Algorithm）或區塊維德曼法（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的冪次方）

接著，使用量子神諭（Quantum Oracle） $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[Hadamard轉換產生全狀態的疊加]
 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）的最大理由。