数学・密码学・量子 on kenji.blog

【完全解剖】什么是量子计算机？〜从零开始理解终极计算原理〜

Sat, 05 Sep 2026 22:10:00 +0900

前言：量子计算机带来的“计算范式转变”

近年来，我们在新闻和技术文章中几乎每天都能看到“量子计算机”这个词。“现在的超级计算机需要计算几千年的问题，它只需几分钟就能完成”、“现有的密码技术可能会全部被破解”等仿佛科幻电影般的故事被传得神乎其神。从Google、IBM、Microsoft等大型IT企业，到世界各地的大学和初创公司，都在为这项梦幻技术的实用化而展开激烈竞争。

然而，如果被问到“量子计算机到底是什么？”，恐怕很少有人能准确回答。许多人可能都有“能够同时计算所有组合的魔法盒子”这样模糊的印象，但严格来说，这是不正确的。

在本文中，我们将从基础开始，彻底且专业但通俗易懂地解说量子计算机与经典计算机（我们平时使用的PC或智能手机）在根本上有什么区别，以及它是如何将“叠加态（Superposition）”、“量子纠缠（Entanglement）”、“量子门（Quantum gates）”等量子力学的奇妙现象应用于计算的。当您读完这篇文章时，应该就能清楚地理解量子计算机真正的厉害之处以及目前面临的挑战。

第1章：经典计算机与量子计算机的决定性差异

为了理解量子计算机的原理，我们首先需要复习一下我们目前使用的“经典计算机”是如何运作的。

比较表：经典计算机 vs 量子计算机

项目	经典计算机	量子计算机
基本单位	比特 (0 或 1)	量子比特 (0和1的叠加)
状态表现	确定性	概率性（在观测之前不确定）
计算方式	串行处理（并行化需要物理核心）	量子并行性（同时操作指数级的状态）
擅长的计算	四则运算、日常数据处理	质因数分解、量子化学计算
容错能力	非常强	非常弱（需要极低温环境或纠错）

经典计算机的世界：非0即1的“比特（Bit）”

经典计算机将所有信息表示为“0”或“1”的状态。这被称为 比特（Bit）。在物理上，它由半导体芯片上晶体管电压的高（1）或低（0）来表示。你智能手机里的高清照片、现在正在阅读的这篇文章，甚至是你最喜欢的YouTube视频，归根结底都可以还原为庞大的“0和1的排列”。计算，无非是将AND（逻辑与）、OR（逻辑或）、NOT（逻辑非）等基本逻辑电路组合起来，对这些0和1的排列进行操作的过程。这是一个非常确定且决定论的世界。只要输入相同，就必定能得到相同的输出。

量子计算机的世界：既是0又是1的“量子比特（Qubit）”

另一方面，量子计算机的最小信息单位被称为 量子比特（Qubit：Quantum bit）。量子比特最大的特点在于，它不像经典比特那样只能处于“0”或“1”的其中一种状态，而是可以呈现出“0和1以特定概率混合的状态”。这被称为 “叠加态（Superposition）”。

例如，如果把经典比特比作抛出后只能是“正面”或“反面”朝上的硬币，那么量子比特经常被比作“在空中持续旋转的硬币”。旋转中的硬币既不能说是正面也不能说是反面，两者的状态叠加在一起。只有当硬币掉落在地板上停止运动的瞬间（这在量子力学中被称为“观测”），它到底是“正面”还是“反面”才会被确定下来。

量子计算机正是将这种微观世界（量子力学）特有的“在观测之前状态不确定”的性质，直接融入到了信息处理的过程中。

第2章：从根本上改变计算的3个量子力学性质

量子计算机惊人计算能力的源泉，并不仅仅是因为它的时钟频率高或者部件小，而在于它将物理法则本身作为计算资源来利用。以下3个量子力学现象是关键。

1. 叠加态（Superposition）与指数级的信息量

如前所述，量子比特可以同时保持0和1两种状态。1个量子比特是“0和1的叠加”，那么增加量子比特的数量会怎样呢？

1个量子比特：2个状态（0, 1）的叠加
2个量子比特：4个状态（00, 01, 10, 11）的叠加
3个量子比特：8个状态的叠加
N个量子比特：$2^N$个模式的叠加

如果只有50个量子比特，就能同时保持$2^{50}$（约1100万亿）个状态。而仅仅300个量子比特，就能一次性保持$2^{300}$个（比宇宙中所有原子的总数还要多！）模式。这种指数级的信息保持能力，构成了量子计算机潜力的基础。要在经典计算机的内存中记住比宇宙原子数量还多的状态，在物理上是不可能的。

2. 量子纠缠（Entanglement）：幽灵般的超距作用

量子纠缠是一种极其违背人类直觉的奇妙现象，甚至连爱因斯坦都称其为“幽灵般的超距作用（Spooky action at a distance）”而终生无法接受。

当多个量子比特进入“量子纠缠”状态时，它们之间会产生强烈的联系，变成一种命运共同体般的关系： “只要其中一个状态确定了，无论它们相隔多远，另一个的状态也会瞬间确定下来”。

例如，假设有两个处于纠缠状态的量子比特A和B（它们分别处于0和1的叠加态）。如果我们观测A发现它是“0”，那么超越信息传递速度极限的光速，B的状态也会瞬间确定下来（比如必定成为“1”）。量子计算机就是通过利用这种量子纠缠，来表达多个量子比特之间复杂的关联性，并进行超并行的数据处理。如果没有纠缠，量子计算机的计算能力将与经典计算机没有多大区别。

3. 量子干涉（Quantum Interference）：让正确答案浮现的魔法

你可能会想：“既然能同时保持所有模式，那只要一次性并行计算，瞬间就能得出答案了吧？”这是对量子计算机最常见的误解。即使在叠加状态下进行了计算，为了最终知道答案，我们还是必须要“观测”。但在观测的瞬间，状态会随机坍缩成$2^N$个模式中的某一个。这样一来，只会得出一个随便的（随机的）答案。

这时就要用到 “量子干涉（Interference）” 了。利用波和波碰撞时，波长一致的地方会相互增强，错开的地方会相互抵消的现象（这在本质上与降噪耳机的原理相同）。

优秀的“量子算法”会在计算过程中巧妙地操作量子态，使得 “导向正确答案的状态（波）的概率振幅相互增强（放大）”，“导向错误答案的状态的概率振幅相互抵消（相消）”。从而确保在最终观测时，“正确答案”能以无限接近100%的概率掉落出来。设计好这种干涉过程，正是量子编程的精髓所在。

第3章：如何进行计算？“量子门”与“量子电路”

就像经典计算机使用逻辑门（AND、OR、NOT等）来进行计算一样，量子计算机也是通过对量子比特施加被称为 “量子门（Quantum Gates）” 的操作来进行计算的。将多个量子门组合在一起就称为 ** 量子电路（Quantum Circuit）**。

量子比特的状态可以用数学上称为“布洛赫球面（Bloch sphere）”的三维球体表面上的一个点来表示。北极是“0”，南极是“1”，赤道上则是“0和1各占一半的叠加态”。所谓量子门，无非就是在球体表面上旋转状态（向量）的操作。

让我们来介绍几个代表性的量子门。

1. 阿达马门（H门）

这是量子计算机独有的、最基本的一种门，在经典计算机中并不存在。如果让状态完全是“0”的量子比特通过H门，就能制造出0和1被观测到的概率正好各占一半的“完全叠加态”（布洛赫球面上赤道上的点）。作为量子计算的初始化步骤，许多算法一开始都会先将H门应用于所有的量子比特。

2. 泡利门（X, Y, Z门）

这些门包含了相当于经典计算机中NOT门（将0翻转为1，1翻转为0）的操作。在布洛赫球面上，它们相当于围绕X轴、Y轴、Z轴旋转180度的操作。特别是X门，它会将北极（0）翻转到南极（1），因此作用与经典的NOT门完全相同。而Z门的作用是翻转叠加态的“相位（类似于波的节奏）”，在引发量子干涉时极其重要。

3. CNOT门（受控非门）

这是用于制造量子纠缠的极其重要的门。它使用两个量子比特（控制比特和目标比特）。它的运作方式是：“如果控制比特为1，则翻转目标比特的状态（X门）。如果控制比特为0，则什么都不做。”乍一看这只是个简单的IF条件分支，但如果控制比特处于“0和1的叠加态”会怎样呢？目标比特将变成“被翻转和未被翻转的叠加态”，两个比特的命运完全联系在一起。两个量子比特就完美地“纠缠”了。

像音乐乐谱一样从左到右依次配置并应用这些门，就能执行复杂的算法。

第4章：量子计算机擅长什么，不擅长什么？

这里要告诉大家一个重要的事实：量子计算机并不是万能的神。在网页浏览、视频渲染、Excel宏处理或一般智能手机应用的运行等日常任务中，量子计算机可能永远无法超越经典计算机。对于这些串行处理任务，已经高度优化、拥有压倒性速度和低廉成本的经典计算机更为适合。

量子计算机只有在面对 “那些经典计算机在计算组合时会呈指数级爆炸，以至于需要花费宇宙寿命般漫长时间的特定问题” 时，才能发挥其真正的价值。这被称为“量子霸权（Quantum Supremacy）”或“量子优势（Quantum Advantage）”。

量子计算机擅长的事情（杀手级应用）

1. 质因数分解与密码破解（Shor算法）

目前，保护互联网安全通信（如信用卡支付、个人信息传输等）的“RSA密码”等，是建立在“使用经典计算机对巨大数字进行质因数分解实际上是不可能的（需要极其庞大的时间）”这一前提之上的。然而，如果使用1994年数学家彼得·秀尔（Peter Shor）发现的“Shor算法”，量子计算机就能巧妙利用干涉，以惊人的速度（多项式时间）破解它。因此，未来的现有密码体系有崩溃的风险，世界各地的中央银行和政府机构正急于向“抗量子密码（Post-Quantum Cryptography）”过渡。

2. 量子化学计算与新材料、新药开发

自然界中分子和原子的行为，原本就遵循量子力学的法则。如果试图用经典计算机来模拟复杂分子的行为，电子之间相互作用的组合将会爆炸，即使是相对较小的分子也会触及计算量的极限。正如诺贝尔物理学奖得主理查德·费曼所说：“如果你想模拟自然，你就必须用量子力学来构建它”，量子计算机在物质模拟方面能够发挥出压倒性的原生力量。人们期待它能带来解决人类面临课题的突破，比如设计划时代的新药、发现常温超导材料、开发高效的太阳能电池和电池材料，以及合成高能效的肥料等。

3. 组合优化问题与搜索（Grover算法）

对于从庞大选项中找出最佳方案的问题（如物流路线优化、金融投资组合优化等），量子算法同样能发挥作用。使用“Grover算法”，在从无序的数据库中搜索目标数据时，只需经典计算机所需次数的平方根就能完成。例如，如果有1亿条数据，经典计算机最多需要1亿次搜索，而量子计算机只需大约1万次即可完成。

第5章：阻碍硬件发展的壁垒——“退相干”与“量子纠错”

虽然在理论上量子计算机拥有如魔法般强大的力量，但在其实用化的道路上，矗立着极高极险峻的物理壁垒。最大的敌人就是 “噪声”。

量子比特的“叠加态”和“量子纠缠”是极其微妙且脆弱的状态。只需接触到周围微小的热量、电磁波的波动甚至宇宙射线，那种神奇的状态就会瞬间崩溃，变回普通的经典比特。这种现象被称为 “退相干（量子崩塌）”。

物理实现方式的激烈竞争

目前，为了解决在物理上如何制造这种微妙的量子比特的问题，世界各地都在研究各种不同的方式，并展开了激烈的霸权争夺。

超导方式（Superconducting）：被Google、IBM、Amazon等采用。使用环状超导电路，通过巨大的制冷机冷却到接近绝对零度（约-273℃）的极低温来控制量子态。这是目前最领先、最容易增加量子比特数量的方式，但冷却设备庞大且昂贵。
离子阱方式（Trapped Ion）：被IonQ、Quantinuum等采用。将离子（原子）用电磁场困在真空中，并用精密的激光照射进行控制。所有量子比特都是均匀的，能长时间保持状态（相干时间长）是其优势，但存在操作速度比超导慢的问题。
光量子方式（Photonic）：PsiQuantum等公司正致力于此。使用光粒子（光子）。很大一部分可以在室温下运行，不需要极低温环境，最大的优点是与现有的硅芯片制造技术和光纤通信技术兼容性好。
拓扑方式（Topological）：Microsoft多年来一直在研究。这是一种野心勃勃的方法，试图利用被称为任意子的特殊粒子的拓扑（拓扑学）性质，制造出从根本上对环境噪声有很强抵抗力（不容易发生错误）的量子比特。理论上最强，但物理实现的门槛被认为是最高的。

迈向终极目标“容错量子计算机（FTQC）”之路

在我们现在使用的经典计算机世界里，其实也存在计算错误（比如宇宙射线导致的比特翻转），但由于“纠错码”能完美地将其修正，我们才能在完全意识不到错误的情况下使用智能手机。为了让量子计算机也能进行实用的大规模计算，同样的 “量子纠错（Quantum Error Correction: QEC）” 是必不可少的。

然而，由于量子态具有“一观测就会崩溃”的性质，所以存在一个致命的悖论：为了确认错误，我们不能直接查看（观测）里面的内容。为了绕过这个问题，人们建立了一种理论（如表面码等）：通过巧妙组合大量不稳定的“物理量子比特”，来构建1个能够检测和修正错误的稳定“逻辑量子比特”。但是，据说为了制造1个逻辑量子比特，需要1000到1万个物理量子比特。如果要使用数千个逻辑量子比特来执行Shor算法等，整个系统就需要拥有数百万到数千万个物理量子比特。

我们现在所处的时代，被称为 NISQ（Noisy Intermediate-Scale Quantum：含噪声中型量子） 设备时代。这是一种没有纠错功能、只能在几十到几百个量子比特下运行的过渡期机器。专家预测，要实现完全能够纠错的终极目标—— “容错量子计算机（Fault-Tolerant Quantum Computer: FTQC）”，还需要进行10年到几十年的长期研发。

第6章：量子计算机的历史与未来展望

最后，让我们俯瞰一下量子计算机是如何诞生的，以及它未来将走向何方。

从理论诞生到证明“量子霸权”

1980年代：物理学家保罗·贝尼奥夫和理查德·费曼提出了利用量子力学原理的计算机概念。“如果要模拟自然，就使用量子力学吧”这句话成为了发端。
1994年：彼得·秀尔发表了用于质因数分解的量子算法（Shor算法）。这震惊了世界，也成为了巨额研究资金流入的契机。
1996年：洛夫·格罗弗（Lov Grover）发表了加速数据搜索的Grover算法。
**2019年 **：历史性的里程碑。Google宣布，使用53个量子比特的超导处理器“Sycamore”，在约200秒内完成了经典超级计算机需要花费1万年（据称）才能完成的随机数生成验证计算。作为世界首次宣告证明 “量子霸权（Quantum Supremacy）” 的事件，引起了巨大轰动（后来IBM等改进了经典超级计算机端的算法，反驳称几天就能计算完，引发了热烈讨论）。
2023年以后：IBM发布了超过1000个量子比特的处理器“Condor”。此外，哈佛大学等成功生成并操作了“逻辑量子比特”，纠错技术的初期实证报告开始陆续出现。

面向下一代技术

量子计算机并不仅仅是“时钟频率更快的下一代CPU”。它用支配微观世界的量子力学法则从根本上改写了计算行为本身的观念，这确实是信息科学中的一次范式转变。

在我们有生之年，大概不会拥有能放进口袋的“个人量子智能手机”（因为那也没有必要）。但是，在AWS或Azure等云网络背后的强大量子数据中心，有朝一日突然发现了不治之症的特效药，或者计算出了能解决全球变暖的梦幻清洁能源材料（例如在常温下从大气中的氮气合成氨的催化剂），这样的未来确实正在逼近。

目前还相当于1940年代的ENIAC（电子数值积分计算机）那样的黎明期——巨大的真空管发出的热量让整个房间变得酷热，还要靠打孔卡来运行。但是，全世界顶尖的研究人员和工程师正在绞尽脑汁，每天都有技术突破的报告。能够实时见证这个新“计算黎明”进化过程的我们，可以说生活在一个在历史上非常令人兴奋的时代。

通向量子世界的大门才刚刚开启。未来的动向值得我们密切关注。

本文的目的是为了向商务人士和对技术感兴趣的普通大众，以通俗易懂的方式解说量子计算的基本概念。请注意，本文在严密的数学和物理学定义（如狄拉克符号（Bra-ket记号）、复数概率振幅的细节等）上进行了一定程度的简化。

【完全解剖】使用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）”的完整面貌。

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

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]

立即购买

柯克霍夫原则

Wed, 16 Apr 2025 23:53:08 +0900

柯克霍夫原则

大家好！

今天想和大家聊一个有点意思，而且实际上非常重要的“柯克霍夫原则”。

啊，等等等等。
也许有人会想：“什么‘柯克霍夫原则’，根本没听说过，那么多片假名看着就头晕……”请放心。这篇文章正是为你准备的。

“安全的密码”到底是什么意思？

比如有人跟你说：“这个保险箱，只有知道秘密开法的人才能打开。”

乍一听，感觉超级安全吧。
但是，仔细想想，难道不会觉得有点不安吗？

“要是那个秘密暴露了，不就全完了吗？”

其实，这正是柯克霍夫原则登场的契机。

到底什么是“柯克霍夫原则”？

这个原则简单来说，就是：

“即使密码系统的机制暴露了，也应该是安全的。”

说得更明确一点，就是“安全性只能依赖于‘密钥’，密码本身的加密方法公开也没关系！”

反过来说，如果“只是把密码算法（机制）当作秘密，那么它的可靠性就会被认为很低”。

“只要机制保密就安全”——这种想法可能有点危险

我们经常会听到这样的说法：

“这个应用的代码谁也没给看过，所以安全性没问题。”

我能理解这种心情。
但这就像在说：“因为谁也没看过，所以就找不到坏处，肯定没问题吧。”

而实际上，“谁也没看过”这件事本身，有时就会成为一种风险。

但是，为什么这个原则那么重要？

因为，如果有人拿到了机制，并且能轻易破解，那么这个密码系统就彻底完蛋了。

打个比方，这就好比你家门锁的结构非常复杂，但实际上用百元店买的万能钥匙就能打开。

重要的不是“锁保密所以安全”，而是“就算把锁的结构全给你看，没有正确的钥匙你也打不开”。

“可是，这样不觉得可怕吗？”

很多人在这里会觉得：

“把机制全都暴露出来，不觉得可怕吗？”

我很理解。
因为大家都会想：“要是全让人看了，会不会被模仿、被恶意利用啊？”

但这正是柯克霍夫原则的核心所在。
“即使给人看也坚不可摧的强度”，才是真正的安全。

话虽如此，一开始还是需要点勇气的

如果站在开发者的角度想，“公开机制=弱点也会被看到”，这当然会让人心跳加速。

但是，请想一想。

能够坦诚地公开机制，并说“欢迎任何人来验证”的东西，结果反而会更受信任。

这和人际关系很像。

“在你展现了真实的自己后，还能和你愉快相处的人”，才是最让人安心的。

总而言之

柯克霍夫原则听起来可能有点理论化，但它的本质非常简单。

只不过是说 “我们要打造一个不管给谁看都不会被破坏的机制”。

比起表面的保密，更需要的是靠谱的设计。
比起不想给任何人看的代码，更需要的是公开也不觉得丢人的代码。

或许，在未来的时代，会越来越需要这种“强度”吧。

感谢你的阅读！

安全的话题虽然有点难，但其实它和“人际关系”、“日常生活中的安全感”也有相通的地方。
不用觉得有压力，只要慢慢了解，一定会发现其中的好处。

数学的历史

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

古希腊三大作图问题

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

阿基米德螺线

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

帕普斯定理

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

年表

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

参考

数学的历史

在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$ 的值全部为素数