A record computation of Khinchin's constant to 2,000,000 decimal digits — rigorously certified, independently cross-checked, and completed in under nine hours on a single desktop machine. Code, digits, and raw telemetry: github.com/reza-ghazi/khinchin-fast · archived at doi:10.5281/zenodo.22134905.
Write a real number x as a simple continued fraction:
In 1935 Aleksandr Khinchin proved something remarkable: for almost every real number — all but a set of Lebesgue measure zero — the geometric mean of the partial quotients a1, a2, a3, … converges to one universal constant, independent of the number chosen:
The constant has a closed product form,
and is entry A002210 in the OEIS. It sits at the center of the metric theory of continued fractions, yet almost nothing is known about it as a number: it is not known whether K0 is irrational, let alone transcendental — and, in a pleasant irony, it is not known whether K0's own continued fraction obeys Khinchin's theorem (numerically, it appears to).
For constants like π, hypergeometric series with rational terms admit binary splitting, giving quasi-linear algorithms — which is why π is known to hundreds of trillions of digits. No such series is known for K0. Every practical method goes through the even zeta values: taking logarithms of the product and expanding gives the Bailey–Borwein–Crandall series
a sum over infinitely many algebraically independent transcendentals ζ(2), ζ(4), …, each needed essentially to full precision. Nobody has found a way around that, and every known algorithm costs on the order of d² (up to logarithmic factors) for d digits: each 10× in digits costs ~100× in time. That quadratic wall is why the record history is so short:
| Year | Digits | Who / method |
|---|---|---|
| 1959–60s | tens | Shanks, Wrench and others |
| 1997 | 7,350 | Bailey, Borwein, Crandall — accelerated zeta series |
| 1998 | 110,000 | Gourdon — refined acceleration |
| 2016 | 1,000,000 | Simó — PARI, ~12 days, single core |
| 2026 | 2,000,000 | this computation — 8 h 47 m, one desktop machine |
The program (khinchin_fast.c, a single C file on FLINT/Arb ball arithmetic with OpenMP) evaluates the accelerated form of the BBC series: for a cut-off N,
whose n-th term now shrinks like N^(−2n), so about P / (2 log2 N) terms suffice for P bits. Three further ideas carry most of the speed:
Dropping precision. A term of magnitude N^(−2n) contributes at most P − 2n·log2 N bits to the final sum, so almost all arithmetic runs far below full precision. The shared power tables drop precision per entry the same way.
A two-region split. For n above ~P/(2(log2 N + 3)) the term ζ(2n) − 1 − Σ k^(−2n) is computed as the literal tail sum Σ_{k≥N} k^(−2n) at low precision — no Bernoulli numbers at all. Below the split, where ζ(2n) is genuinely near 1 and needs full precision, FLINT's reverse Bernoulli iterator (bernoulli_rev) reconstructs it. Work is split into cost-balanced blocks scheduled dynamically across all threads.
Rigor by construction. All arithmetic is Arb ball arithmetic: every intermediate is an interval guaranteed to contain the true value, every truncation is folded in as an explicit error bound, and the final decimal is produced by a proof-carrying rounding step that only prints digits when the ball certifies a unique correctly rounded value. There is no "estimated error" anywhere — a wrong digit is impossible; failure would be loud, not silent.
The zeta-acceleration structure is adapted from Remco Bloemen's MIT-licensed recmo/khinchin; the repository's MATHEMATICS.md gives the full derivation and history.
On August 27, 2026, the program computed 2,000,000 digits after the decimal point in one run:
The run pushed the machine to its edge: the program's own conservative memory preflight refuses 2,000,000 digits on a 64 GB machine (estimate: 61.7 GiB) and had to be overridden with --force; measured peak was 55.8 GiB, within 6 GiB of physical RAM, and a standby swapfile went unused. Memory, not time, is the binding constraint — the dominant allocation is the internal state of the reverse Bernoulli iterators, which grows roughly quadratically with the digit count. The local cost exponent, ~d^2.0 at small sizes, steepens to ~3.2 between one and two million digits as that state overwhelms the caches. The next doubling would need well over 128 GB of RAM and an out-of-core redesign, and a billion digits remains out of reach for everyone: the exponent, not the constant factor, is the obstruction.
Three independent legs support the result:
arb_zeta_ui at full precision) sharing only the outer series framing. The two agree byte-for-byte at every size tested.Everything is in the repository github.com/reza-ghazi/khinchin-fast (MIT license): the C program, the 2,000,000-digit result (khinchin-2m.txt), the raw run telemetry (khinchin-2m.log), the mathematical background document, and — as a byproduct of validating the algorithm — reference implementations of the same accelerated series in seventeen further languages, from FLINT-backed C++/Rust/Julia/Fortran to pure-bignum Go/Java/Haskell/OCaml, every one verified byte-identical to the C program's output. A single make check rebuilds and re-verifies the whole set. The repository is permanently archived at Zenodo: doi:10.5281/zenodo.22134905. Since August 31, 2026 the computation is also listed in the links of the constant's OEIS entry, A002210. This article is also republished on Medium.
The software and this write-up were developed with the assistance of Claude (Anthropic), used as a programming and drafting tool under the author's direction; all results are independently verifiable as described in § 5.