1988年，美籍乌克兰裔数学家兄弟 大卫·丘德诺夫斯基（David Chudnovsky）和 格雷戈里·丘德诺夫斯基（Gregory Chudnovsky）发表了一个改进的 计算级数。这个公式后来被称为丘德诺夫斯基算法（Chudnovsky algorithm）：
这个公式每个新项可以增加约 14 位十进制精度——比拉马努金公式（约 8 位/项）几乎翻了一倍。自 1990 年代以来，几乎所有 的世界纪录计算都依赖丘德诺夫斯基算法或其变体。
里程碑意义：丘德诺夫斯基算法是超快速收敛 级数的巅峰之作，以每秒数百万位的速度推动着 的纪录从 10 亿位跃升至 100 万亿位。
丘德诺夫斯基公式有两种常用形式：
形式一（标准形式）：
形式二（更常见的计算形式，消除分数指数）：
其中 。
公式中的关键常数：
| 常数 | 数值 | 作用 |
|---|---|---|
| 收敛基底的整数部分 | ||
| 初始偏移常数 | 决定级数的起始值 | |
| 线性系数 | 控制每项 的线性增长 | |
| 前置系数 | 归一化常数 |
这些常数来源于模函数 的特定值。 在 处的值为：
数字 163 的"神奇"之处在于： 的类数为 1（是虚二次域的最后一个类数 1 的判别式），这保证了级数具有最优收敛性质。
丘德诺夫斯基公式本质上是拉马努金公式的推广和优化。
| 性质 | 拉马努金公式 | 丘德诺夫斯基公式 |
|---|---|---|
| 发表时间 | 1914 | 1988 |
| 每项精度 | 位十进制 | 位十进制 |
| 收敛基数 | ||
| 分母增长 | ||
| 分子复杂度 | ||
| 计算 100 万位所需项数 | 项 | 项 |
拉马努金没有给出他公式的证明（他的"直觉"来源于对模方程的深刻洞察）。丘德诺夫斯基兄弟利用现代数论工具完成了严格推导，并将收敛速度提升到了接近理论极限。
定义级数的第 项为 。对于丘德诺夫斯基算法：
当 时，比值趋近于：
这意味着每项贡献约 位十进制精度。
具体数值示例：已用项数与对应精度
| 项数 | 累加项 | 理论精度（十进制位） | 举例 |
|---|---|---|---|
| 0 | 1 | 前1项： | |
| 1 | 2 | 位正确 | |
| 2 | 3 | 位正确 | |
| 10 | 11 | 位正确 | |
| 100 | 101 | 位正确 | |
| 1{,}000 | 1{,}001 | 位正确 | |
| 100{,}000 | 100{,}001 | 百万 | 百万位级别 |
| 1{,}000{,}000 | 1{,}000{,}001 | 百万 | 千万位级别 |
计算 100 万位 只需要约 71,000 项级数——这是在个人计算机上几秒钟就能完成的计算。
| 目标精度 | 丘德诺夫斯基所需项数 | 马钦公式所需项数 | 莱布尼茨公式所需项数 |
|---|---|---|---|
| 10 位 | 1 | 4 | |
| 100 位 | 8 | 40 | 不可行 |
| 1,000 位 | 71 | 334 | 不可行 |
| 1 百万位 | 70,579 | 约 330 亿 | 不可行 |
| 10 亿位 | 70,579,000 | — | — |
| 100 万亿位 | — | — |
莱布尼茨公式每项仅增加约 0.3 位，要算 100 位就需要 项——全宇宙的原子联合计算也做不到。
直接计算丘德诺夫斯基级数逐项求和虽然简单，但每项都包含巨大的阶乘运算。实际实现中必须使用二进制分裂（Binary Splitting）技术。
二进制分裂的核心思想：将级数 的求和转化为递归分治，避免重复计算阶乘。
定义丘德诺夫斯基级数的第 项为：
其中 , , 。
二进制分裂的递归结构：
函数 BS(l, r):
如果 r - l == 1:
返回 (P, Q, T) 其中:
P = C^{3l}
Q = (-1)^l (3l)! (l!)^3
T = (6l)! (A + Bl) * P / Q
否则:
m = (l + r) // 2
(P1, Q1, T1) = BS(l, m)
(P2, Q2, T2) = BS(m, r)
返回 (P1*P2, Q1*Q2, T1*Q2 + T2*P1)
最终结果：
其中 。
计算复杂度：二进制分裂将计算复杂度从 降为 ，使得数十亿项的计算成为可能。
以下仅为说明算法的 Python 实现逻辑，实际世界纪录计算使用 C/C++ 和大数库（GMP）。
from decimal import Decimal, getcontext
def chudnovsky_pi(precision_digits):
"""使用丘德诺夫斯基级数计算 π（使用 Decimal 类型）"""
getcontext().prec = precision_digits + 10 # 保留额外位数
C = Decimal(640320)
C3 = C ** 3 # 640320^3
# 常数
A = Decimal(13591409)
B = Decimal(545140134)
# 计算需要的项数
# 每项约 14.18 位，向上取整
import math
num_terms = int(precision_digits / 14.18) + 2
total = Decimal(0)
for k in range(num_terms):
# 计算阶乘
k6_fact = math.factorial(6 * k)
k3_fact = math.factorial(3 * k)
k_fact = math.factorial(k)
# 分子
numerator = (-1) ** k * k6_fact * (A + B * k)
# 分母
denominator = k3_fact * (k_fact ** 3) * (C3 ** k)
term = Decimal(numerator) / Decimal(denominator)
total += term
# 乘以常数 12 / (C * sqrt(C))
const = Decimal(12) / (C * C.sqrt())
pi = 1 / (total * const)
return pi
# 计算 100 位 π
pi_100 = chudnovsky_pi(100)
print(str(pi_100)[:102])
# 输出: 3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679
现代 世界纪录计算全部使用 GMP（GNU Multiple Precision Arithmetic Library）：
#include <gmpxx.h>
#include <iostream>
// 二进制分裂的递归实现
void bs(unsigned long a, unsigned long b,
mpz_class &P, mpz_class &Q, mpz_class &T) {
if (b - a == 1) {
// 基础情况：计算单一项
P = 1;
Q = 1;
for (unsigned long i = 1; i <= 6 * a; i++)
P *= i; // (6a)!
for (unsigned long i = 1; i <= 3 * a; i++)
Q *= i; // (3a)!
mpz_class fact_k = 1;
for (unsigned long i = 1; i <= a; i++)
fact_k *= i; // a!
Q = Q * fact_k * fact_k * fact_k; // (3a)! * (a!)^3
mpz_class pow_factor;
mpz_ui_pow_ui(pow_factor.get_mpz_t(), 640320, 3 * a);
P = P * pow_factor;
T = P * (13591409 + 545140134 * a);
return;
}
unsigned long m = (a + b) / 2;
mpz_class P1, Q1, T1, P2, Q2, T2;
bs(a, m, P1, Q1, T1);
bs(m, b, P2, Q2, T2);
P = P1 * P2;
Q = Q1 * Q2;
T = T1 * Q2 + T2 * P1;
}
int main() {
mpz_class P, Q, T;
unsigned long terms = 100000; // 约 140 万位
bs(0, terms, P, Q, T);
// 计算 S = 12 * C^(3/2)
mpf_class C_sqrt;
mpf_sqrt(C_sqrt.get_mpf_t(), mpf_class(640320).get_mpf_t());
mpf_class S = mpf_class(12) * mpf_class(640320) * C_sqrt;
// π = T / (Q * S)
mpf_class pi = mpf_class(T) / (mpf_class(Q) * S);
// gmp_printf 输出
mp_exp_t exp;
char *str = mpf_get_str(NULL, &exp, 10, 1000001, pi.get_mpf_t());
// str[0..exp-1] = π 的小数部分
return 0;
}
| 年份 | 计算者 | 纪录（十进制位） | 硬件 | 算法 |
|---|---|---|---|---|
| 1989 | 丘德诺夫斯基兄弟 | 4.8 亿 | Cray-2 + IBM 3090 | 丘德诺夫斯基 |
| 1997 | 安正弘（Takahashi） | 515 亿 | HITACHI SR2201 | 丘德诺夫斯基 |
| 2002 | 安正弘 | 1.24 万亿 | HITACHI SR8000 | 丘德诺夫斯基 |
| 2009 | 高桥大介（Takahashi Daisuke） | 2.57 万亿 | 个人计算机集群 | 丘德诺夫斯基 |
| 2010 | 近藤茂（Shigeru Kondo） | 5 万亿 | 个人计算机 | 丘德诺夫斯基 |
| 2011 | 近藤茂 | 10 万亿 | 个人计算机 | 丘德诺夫斯基 |
| 2013 | 近藤茂 | 12.1 万亿 | 个人计算机 | 丘德诺夫斯基 |
| 2014 | 近藤茂 | 13.3 万亿 | 个人计算机 | 丘德诺夫斯基 |
| 2019 | 高桥大介 | 31.4 万亿 | 个人计算机 + Google Cloud | 丘德诺夫斯基 |
| 2020 | 存储实验室（Storage Review） | 50 万亿 | 个人计算机 + 存储服务器 | 丘德诺夫斯基 |
| 2021 | 高桥大介 + Google Cloud | 100 万亿 | Google Cloud 基础设施 | 丘德诺夫斯基 |
| 2022 | 存储实验室 | 100 万亿（验证） | 个人计算机 | 丘德诺夫斯基 |
| 2024 | 存储实验室 | 105 万亿 | 个人计算机 | 丘德诺夫斯基 |
关键观察：从 2010 年开始，丘德诺夫斯基算法已经可以在个人计算机上打破 计算的世界纪录。瓶颈不再是 CPU 速度，而是内存带宽和存储容量。
2021 年 Google Cloud 的 100 万亿位计算（使用 y-cruncher 程序）：
| 资源 | 消耗 |
|---|---|
| 计算节点 | 1 台（主）+ 多台辅助 |
| CPU | Intel Xeon (Skylake)，28 核 |
| 内存 | 约 1.5 TB（存储级内存） |
| 主计算时间 | 约 158 天 |
| 验证时间 | 约 52 天 |
| 总存储 | 约 82 TB（校验和数据） |
| 最大 文件大小 | 约 37 TB |
y-cruncher 是 Alexander Yee 开发的专门用于 和其他数学常数的计算软件。自 2009 年以来，它是所有 世界纪录计算的标准工具。
y-cruncher 的核心特性：
| 算法 | 理论每项精度 | 实际速度（万亿位/天） | 内存效率 |
|---|---|---|---|
| 丘德诺夫斯基 | 14.18 位 | 高 | |
| 拉马努金 | 8.02 位 | 中 | |
| AGM（算术几何平均） | 二次收敛 | 低 | |
| Borwein | 四次收敛 | 低 |
虽然 AGM 算法的渐进收敛速度更快（每步翻倍），但丘德诺夫斯基算法的大常数使得它在实际万亿位计算中仍然占优。这是"理论复杂度"与"实际工程可行性"之间的经典矛盾。
计算 的最大挑战不是"算出来"，而是验证正确性。常用的验证方法：
除了基准测试（benchmarking）和系统压力测试外， 的高位计算没有"实用价值"——但它是计算机科学的最佳压力测试：
| 测试项目 | 为什么 计算最合适 |
|---|---|
| CPU 浮点性能 | 大整数乘法（FFT/NTT）消耗数十亿次运算 |
| 内存带宽 | 每秒数 GB 的数据读写 |
| 内存延迟 | 随机访问数百 GB 数据 |
| 存储性能 | 分页交换到 SSD/NVMe |
| 并行扩展性 | 多线程/分布式计算的负载均衡 |
| 散热/功耗 | 连续数月的满负荷运行 |
| 系统稳定性 | 任何硬件错误都会导致计算结果错误 |
丘德诺夫斯基算法的深层数学原理源于模函数 和椭圆积分之间的关系。为了理解公式的"神奇常数"，我们需要了解：
函数：
其中 ， 是除数函数 。
当 时：
这并非巧合——163 是使得 的类数为 1 的最大的 （Heegner 数，共 9 个）。
这 9 个 Heegner 数（ 使得 类数为 1）是：
最大的 163 产生最大的 值，从而带来最快的收敛速度。具体来说：
这解释了为什么每项能贡献约 14 位精度（，开立方后约 ）。
练习 1：证明丘德诺夫斯基公式的收敛比 约等于 ，并计算其十进制位数的增益。
化简后得到：
，即每项约 14.18 位十进制精度。
练习 2：使用高精度计算库（如 Python decimal 或 mpmath）计算丘德诺夫斯基级数的前 3 项，与已知的 值对比，查看已经达到多少位精度。
答案参考：前 3 项（k=0,1,2）即可得到约 42 位精度的 ：
为什么丘德诺夫斯基算法不能直接验证 的特定位？ 因为它需要知道前面的所有项——它不是一个"spigot algorithm"（水龙头算法）。而 BBP 公式可以在不前面项的情况下计算 的十六进制某一位。
什么样的数学结构会导致更快的 级数？ 理论上，如果存在类数更大的虚二次域，对应的 值会更大，从而得到更快的收敛速度。但 163 已经是最大的类数 1 判别式。
丘德诺夫斯基算法在 GPU 上是否更高效？ 丘德诺夫斯基算法涉及大量大整数乘法（FFT/NTT），对于 GPU 的大规模并行 FFT 有天然的友好性。但目前 世界纪录仍然主要使用 CPU，因为 GPU 的内存容量通常远小于 CPU。
丘德诺夫斯基算法是 计算领域的终极武器：
从 1988 年的 4.8 亿位到 2024 年的 105 万亿位，丘德诺夫斯基算法跨越了 6 个数量级。随着存储技术（特别是 Intel Optane 和新型 NVMe）和计算架构的发展，该算法有望在未来推动 向千万亿位（）进军。
参考资源：