A new challenge to a 280-year-old unsolved mathematical problem
I’ve achieved a new world record in verifying the Goldbach Conjecture, a famous unsolved problem in mathematics, by extending the verification up to 4 quintillion (4×10¹⁸) + 70 trillion (7×10¹³). This article introduces Gridbach, the grid computing system I developed for this computation.
Check out my live grid computing system here:
https://gridbach.com
No login is required. You can immediately see the computation results on both PC and mobile.
I am @jay_gridbach, a freelance engineer and consultant based in Kanagawa, Japan. Currently, I work as a PreSales engineer at a company in Tokyo, while also developing web applications and my own services. Gridbach is a project I’ve been nurturing since my corporate days, and I’m thrilled to release it in April 2025.
The Goldbach Conjecture, proposed by Prussian mathematician Christian Goldbach in 1742, remains an unsolved problem in mathematics. Despite the efforts of numerous modern mathematicians, no one has proven it mathematically. The conjecture itself is simple enough for a middle school student to understand:
“Every even natural number greater than 2 is the sum of two prime numbers”
Examples:
4 = 2 + 2
6 = 3 + 3
8 = 3 + 5
…
100 = 3 + 97
…
10000 = 71 + 9929
…
1000000000001092576 = 1913 + 1000000000001090663
…
While it’s believed to be true, a mathematical proof for all even numbers is still elusive.
In 2013, T. Oliveira e Silva from Portugal verified the conjecture up to 4×10¹⁸ using computers. This was the previous world record.
https://sweet.ua.pt/tos/goldbach.html
My newly developed Gridbach system has slightly surpassed this record by adding 70 trillion to the verified range. I aim to push this further to 5 quintillion by increasing the number of participating machines and improving my algorithms. I’m not sure how to get this recognized as an official record, but I’m willing to write a paper if necessary. If anyone has insights on this, please let me know.
- Gridbach is a cloud-based distributed computing system accessible from any PC or smartphone.
- It requires no login or app installation. The high-performance WASM (WebAssembly) binary code is downloaded as browser content, enabling computation on the user’s browser.
- Each computation job covers a range of 100 million (50 million even numbers), taking about 5–10 seconds on a PC and 10–20 seconds on a smartphone.
- Inspired by SETI@home, I’ve aimed to create a system that anyone can easily join.
My system uses a combination of high-performance WASM for efficient computation and a highly scalable JAMStack architecture.
The challenges and lessons learned in choosing and setting up this stack are worth a separate post.
The app is simple, offering two main features: running computations on your machine and viewing the collective results from all Gridbach users. It’s also mobile-friendly.
For details on the dashboard data, please visit – https://app.gridbach.com/
I define “Goldbach Ridge” as the maximum value of the smaller prime in the prime pairs satisfying the Goldbach Conjecture within a given range.
While T. Oliveira e Silva refers to these as the smaller prime p in the Goldbach partition, I named them as “ridge” as graphing these looks like mountain peaks and cols.
Oliveira e Silva al. discovered a large Goldbach ridge of 9781:
Feel free to join in and see if you can find some bigger peaks! So far, 6421 is the largest one found on my system. Your top 30 Goldbach Peaks are displayed on the My Calculation screen.
The core computation logic of mine is open-sourced as a Go command-line tool under the MIT license.
https://github.com/nakatahr/gridbach-core
Here’s a snippet of the code. I’ve upgraded the Sieve of Eratosthenes to use bitwise operations on byte arrays for faster prime number generation, and optimized it for given ranges.
// b0 b1 b2 b3 b4 b5 b6 b7
// [i0] 1 3 5 7 9 11 13 15
// [i1] 17 19 21 23 25 27 29 31
// [i2] 33 35 37 39 41 45 47 49
// To access x,
// i : (x-1)/16 : x>>4
// b : (x%16-1)/2 : (x&15)>>1flags := [...]byte{
0b00000001, 0b00000010, 0b00000100, 0b00001000,
0b00010000, 0b00100000, 0b01000000, 0b10000000}
masks := [...]byte{
0b11111110, 0b11111101, 0b11111011, 0b11110111,
0b11101111, 0b11011111, 0b10111111, 0b01111111}
var xmax = uint32(math.Sqrt(float64(to)))
var yz = uint32(to - from + 1)
for x := uint32(3); x <= xmax; x += 2 {
if root[x>>4]&flags[(x&15)>>1] != 0 {
// Yield the mm (minimum multiple) of x satisfying mm > from
var q, r = bits.Div64(0, from, uint64(x))
if r != 0 {
q++
}
if q&1 == 0 {
q++
}
var mm = uint64(x) * q
var ya = uint32(mm - from)
// Put off bit for every multiples
for y := ya; y < yz; y += x << 1 {
prime[y>>4] &= masks[(y&15)>>1]
}
}
}
I also plan to write a separate article about the computation algorithm.
Thank you for reading! Please take 5 minutes to try the computation on gridbach.com. I aim to continue breaking records and improving the system, hoping to spark interest in mathematics and IT.
