🔢 mathematics

GoldbachGPU: An Open Source GPU-Accelerated Framework for Verification of Goldbach's Conjecture

GoldbachGPU एक ओपन-सोर्स, सेगमेंटेड GPU फ्रेमवर्क है जो एक एकल कंज्यूमर GPU पर 10^12 तक गोल्डबैक की परिकल्पना (गोल्डबैक्स कंजक्चर) को थकावटपूर्ण रूप से सत्यापित करने के लिए पिछली मेमोरी सीमाओं को दूर करता है और 10^10000 तक अनिश्चित-परिशुद्धता सत्यापन को विस्तारित करता है, साथ ही मल्टी-जीपीयू डेटा-सेंटर हार्डवेयर में स्वच्छ स्केलेबिलिटी का प्रदर्शन करता है।

मूल लेखक: Isaac Llorente-Saguer

प्रकाशित 2026-03-04

📖 6 मिनट में पढ़ें🧠 गहराई से पढ़ें

CC BY 4.0

मूल लेखक: Isaac Llorente-Saguer

मूल पेपर CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/) के तहत लाइसेंस किया गया है। ✨ नीचे दिए गए पेपर की यह व्याख्या AI से तैयार की गई है। इसे लेखकों ने न तो लिखा है, न इसका समर्थन किया है। तकनीकी सटीकता के लिए मूल पेपर देखें। पूरा डिस्क्लेमर पढ़ें

कल्पना कीजिए कि आप एक विशाल पहेली को हल करने की कोशिश कर रहे हैं। यह पहेली गोल्डबैक के अनुमान (Goldbach's Conjecture) के बारे में है, जो 1742 से चली आ रही एक गणितीय समस्या है। इसका नियम सरल है: 2 से बड़े प्रत्येक सम संख्या (even number) को दो अभाज्य संख्याओं (prime numbers) को जोड़कर बनाया जा सकता है।

उदाहरण के लिए:

4 = 2 + 2
10 = 3 + 7
100 = 3 + 97

गणितज्ञों ने खरबों संख्याओं के लिए इसकी जांच की है, लेकिन वे इसे अस्तित्व में मौजूद हर एक संख्या के लिए सिद्ध नहीं कर पाए हैं। यह शोध पत्र एक नया टूल पेश करता है जिसे GoldbachGPU कहा जाता है, जो एक मानक कंप्यूटर ग्राफिक्स कार्ड (वही जो गेमर्स उपयोग करते हैं) का उपयोग करके इन संख्याओं की अविश्वसनीय गति से जांच करता है।

यह पेपर कैसे काम करता है, इसे रोजमर्रा के उदाहरणों के माध्यम से समझाया गया है:

1. पुरानी समस्या: "फाइलिंग कैबिनेट" की बाधा (The "Filing Cabinet" Bottleneck)

कल्पना कीजिए कि आप एक लाइब्रेरियन हैं जो यह पता लगाने की कोशिश कर रहे हैं कि क्या कोई विशिष्ट पुस्तक मौजूद है। अतीत में, कंप्यूटर वैज्ञानिकों ने कंप्यूटर की सुपर-फास्ट मेमोरी (VRAM) में प्रत्येक अभाज्य संख्या (किताबें) की एक सूची डालने की कोशिश की ताकि उन्हें तुरंत जांचा जा सके।

समस्या: अभाज्य संख्याओं की सूची बहुत बड़ी है। जैसे-जैसे संख्याएँ बढ़ती हैं, सूची इतनी लंबी हो जाती है कि वह कंप्यूटर की मेमोरी में फिट नहीं बैठती। यह एक पूरे पुस्तकालय की किताबों को एक अकेले बैकपैक में ठूंसने की कोशिश करने जैसा है।
सीमा: पिछले प्रयासों ने 100 बिलियन ( $10^{11}$ ) के आसपास एक "दीवार" का सामना किया। एक बार जब सूची बैकपैक के लिए बहुत बड़ी हो गई, तो कंप्यूटर को रुकना पड़ा।

2. समाधान: "स्मार्ट सेगमेंटेशन" रणनीति (The "Smart Segmentation" Strategy)

लेखक, आइज़ैक लोरेन्टे-सागुएर (Isaac Llorente-Saguer) ने पूरी लाइब्रेरी को जबरदस्ती बैकपैक में डालने की कोशिश नहीं की। इसके बजाय, उन्होंने एक दो-चरणीय रणनीति बनाई जो यह बदल देती है कि कंप्यूटर उत्तर कैसे खोजता है।

चरण A: "बिट-पैक्ड" सूटकेस (The "Bit-Packed" Suitcase)

सबसे पहले, उन्होंने महसूस किया कि संख्याओं को स्टोर करने का पुराना तरीका बहुत बर्बादी भरा था। यह हर किताब को एक विशाल, खाली कार्डबोर्ड बॉक्स में रखने जैसा था।

सुधार: उन्होंने डेटा को कंप्रेस (संकुचित) कर दिया। हर किताब के लिए एक बड़े बॉक्स के बजाय, उन्होंने एक छोटा, घना सूटकेस इस्तेमाल किया जहाँ एक ही स्थान में 16 किताबें समा सकती थीं। इस 16x संपीड़न (compression) का मतलब था कि कंप्यूटर बिना ओवरफ्लो हुए अपनी मेमोरी में अभाज्य संख्याओं की एक बहुत लंबी सूची रख सकता था।

चरण B: "सेगमेंटेड" असेंबली लाइन (The "Segmented" Assembly Line - सबसे बड़ी सफलता)

इस छोटे सूटकेस के साथ भी, सूची (1 ट्रिलियन या $10^{12}$ तक की संख्याओं के लिए) अभी भी बहुत लंबी थी। इसलिए, उन्होंने वर्कफ़्लो को पूरी तरह से बदल दिया।

कल्पना कीजिए कि आप लोगों की एक लंबी कतार (सम संख्याएं) की जांच कर रहे हैं कि क्या उनके पास एक मिलान करने वाला साथी (अभाज्य संख्या) है।

पुराना तरीका: आप संभावित साथियों की पूरी सूची लेते हैं, उन्हें कतार के पास लाते हैं, और हर व्यक्ति की हर किसी के साथ जांच करते हैं। इसके लिए एक बहुत बड़े कमरे (मेमोरी) की आवश्यकता होती है।
GoldbachGPU का तरीका: आप एक समय में भागीदारों का केवल एक छोटा समूह ही लाइन में लाते हैं।
1. आप लोगों के पहले समूह की जांच करते हैं।
2. यदि आपको एक मिलान मिलता है, तो आप अगले समूह की ओर बढ़ते हैं।
3. यदि आपको छोटे समूह के साथ कोई मिलान नहीं मिलता है, तो आपके पास एक "सुरक्षा जाल" (एक कठोर CPU जांच) होता है, जो यह सुनिश्चित करने के लिए गहरा और धीमा शोध करता है कि आपने कुछ छोड़ा तो नहीं है।

जादू: क्योंकि आपको एक समय में मेमोरी में केवल भागीदारों की एक छोटी "खंड" (segment) रखने की आवश्यकता होती है, इसलिए कंप्यूटर कभी भी जगह की कमी का सामना नहीं करता है। यह एक फैक्ट्री असेंबली लाइन की तरह है जहाँ आप पूरे कारखाने के औजारों के बजाय केवल वर्तमान कार्य के लिए आवश्यक औजारों को ही मेज पर रखते हैं।

3. "ओरेकल" (The "Oracle" - तीन-स्तरीय जासूस)

इसे तेज़ बनाने के लिए, कंप्यूटर यह जांचने के लिए कि कोई संख्या अभाज्य है या नहीं, एक "तीन-स्तरीय जासूस" प्रणाली का उपयोग करता है:

त्वरित नज़र (The Quick Look): क्या संख्या बहुत छोटी है? कंप्यूटर के मस्तिष्क (L2 Cache) में एक छोटी, स्थायी सूची की जांच करें। तत्काल उत्तर।
वर्तमान खंड (The Current Segment): क्या संख्या उस छोटे समूह में है जिस पर हम अभी काम कर रहे हैं? मेज पर मौजूद सूची (VRAM) की जांच करें। बहुत तेज़ उत्तर।
गहन खोज (The Deep Dive): क्या संख्या "बीच के क्षेत्र" में है? सुनिश्चित करने के लिए एक जटिल गणितीय परीक्षण (Miller-Rabin) चलाएं। धीमा, लेकिन आवश्यक।

यह प्रणाली यह सुनिश्चित करती है कि कंप्यूटर अपना 99% समय "त्वरित नज़र" और "वर्तमान खंड" पर बिताता है, जो बहुत तेज़ हैं।

4. परिणाम: रिकॉर्ड तोड़ना (Breaking the Record)

एक मानक गेमिंग ग्राफिक्स कार्ड (NVIDIA RTX 3070, जिसकी कीमत कुछ सौ डॉलर है) का उपयोग करके, यह नया फ्रेमवर्क:

1 ट्रिलियन ( $10^{12}$ ) तक की प्रत्येक सम संख्या की जांच की।
शून्य प्रति-उदाहरण (counterexamples) पाया। (जांची गई हर एक संख्या अभी भी नियम का पालन करती थी)।
लग lभत 41 मिनट में वह काम किया जिसमें पहले कई दिन लग जाते थे या जिसके लिए विशाल सुपरकंप्यूटर की आवश्यकता होती थी।
लगभग कोई मेमोरी उपयोग नहीं किया (प्रति सेगमेंट केवल 14 MB), जिसका अर्थ है कि यदि आवश्यक हुआ तो यह सैद्धांतिक रूप से और भी ऊपर जा सकता है।

उन्होंने व्यक्तिगत, विशाल संख्याओं (10,000 अंक लंबी) की जांच करने के लिए एक विशेष टूल भी बनाया, जो उन्हें सेकंडों में सत्यापित करता है।

5. यह क्यों महत्वपूर्ण है?

यह ओपन सोर्स है: कोई भी कोड डाउनलोड कर सकता है, इसे अपने कंप्यूटर पर चला सकता है और परिणामों को सत्यापित कर सकता है।
यह सुलभ है: आपको मिलियन-डॉलर के सुपरकंप्यूटर की आवश्यकता नहीं है। एक मानक गेमिंग पीसी अब विश्व स्तरीय गणितीय सत्यापन कर सकता है।
यह कुशल है: इसने साबित कर दिया कि पिछला "मेमोरी वॉल" भौतिकी का कोई नियम नहीं था; यह केवल एक खराब डिज़ाइन था। डिज़ाइन बदलकर, हम और भी आगे जा सकते हैं।

संक्षेप में: लेखक ने एक ऐसी समस्या को लिया जो कंप्यूटर में "डेस्क स्पेस" खत्म होने के कारण अटकी हुई थी, और कंप्यूटर को छोटे, प्रबंधनीय शिफ्ट में काम करना सिखाकर इसे हल किया। परिणाम? अब हम अपने घर के कंप्यूटर से ही एक ट्रिलियन तक ब्रह्मांड के नियमों (गणित) की जांच कर सकते हैं।

यहाँ शोध पत्र "GoldbachGPU: गोल्डबैक अनुमान के सत्यापन के लिए एक ओपन सोर्स GPU-त्वरित फ्रेमवर्क" का विस्तृत तकनीकी सारांश दिया गया है।

1. समस्या विवरण (Problem Statement)

गोल्डबैक अनुमान (Goldbach's Conjecture) यह प्रस्तावित करता है कि 2 से बड़ी प्रत्येक सम संख्या (even integer) दो अभाज्य संख्याओं (prime numbers) का योग है। हालांकि यह सैद्धांतिक रूप से अप्रमाणित है, लेकिन वितरित CPU क्लस्टरों का उपयोग करके इसे $4 \times 10^{18}$ तक कम्प्यूटेशनल रूप से सत्यापित किया जा चुका है। हालांकि, कमोडिटी हार्डवेयर (विशेष रूप से एकल उपभोक्ता GPU) पर सत्यापन VRAM (वीडियो रैम) की सीमाओं के कारण गंभीर रूप से सीमित रहा है।

पूर्ववर्ती GPU-आधारित दृष्टिकोण मोनोलिथिक प्राइम टेबल (monolithic prime table) को VRAM में संग्रहीत करने पर निर्भर थे। इसने $10^{11}$ के पास एक "कठोर मेमोरी सीलिंग" (hard memory ceiling) बना दी, क्योंकि बड़े रेंज के लिए संख्या-प्रति-बाइट प्रतिनिधित्व को स्टोर करने के लिए उपभोक्ता कार्डों पर उपलब्ध 8–24 GB VRAM से अधिक मेमोरी की आवश्यकता थी। फलस्वरूप, किसी भी मौजूदा ओपन-सोर्स फ्रेमवर्क ने एकल GPU पर $10^{11}$ से परे व्यापक सत्यापन प्रदर्शित नहीं किया था।

2. कार्यप्रणाली (Methodology)

लेखक GoldbachGPU का प्रस्ताव करते हैं, जो एक फ्रेमवर्क है जिसमें पाँच पूरक उपकरण शामिल हैं जो CPU बेसलाइन से लेकर अनिश्चित परिशुद्धता (arbitrary-precision) सत्यापन तक स्केल करते हैं। मुख्य नवाचार सेगमेंटेड डबल-सीव वेरिफायर (goldbach_gpu3) है।

मुख्य वास्तुशिल्प घटक (Key Architectural Components):

सघन बिट-पैक्ड प्रतिनिधित्व (Dense Bit-Packed Representation):
प्राइम को बाइट्स के रूप में स्टोर करने के बजाय, फ्रेमवर्क एक 64-बिट वर्ड ऐरे का उपयोग करता है जहाँ प्रत्येक बिट एक विषम पूर्णांक (odd integer) का प्रतिनिधित्व करता है। यह बाइट-ऐरे स्टोरेज की तुलना में 16× मेमोरी फुटप्रिंट में कमी लाता है, जिससे $10^{11}$ तक की प्राइम टेबल को 8 GB VRAM (5.96 GB) के भीतर फिट किया जा सकता है।
सेगमेंटेड डबल-सीव आर्किटेक्चर (Segmented Double-Sieve Architecture):
$10^{11}$ की सीमा को पार करने के लिए, फ्रेमवर्क मोनोलिथिक टेबल का त्याग करता है। यह ओलिविरा ई सिल्वा की 'लूप इनवर्जन' रणनीति से प्रेरित एक सेगमेंटेड दृष्टिकोण अपनाता है:
1. लूप इनवर्जन (Loop Inversion): सम संख्याओं $n$ के माध्यम से जाने और प्राइम $p$ खोजने के बजाय, सिस्टम संभावित प्राइम $p$ के माध्यम से जाता है और सम संख्याओं $n$ के लिए वैध विभाजन (partitions) को चिह्नित करता है।
2. सेगमेंटेड प्रोसेसिंग (Segmented Processing): रेंज को सेगमेंट (जैसे, $10^7$ सम पूर्णांक) में विभाजित किया जाता है। प्रत्येक सेगमेंट के लिए, CPU एक छोटा प्राइम बिटसेट (लगभग 14 MB) उत्पन्न करता है और उसे GPU को स्थानांतरित करता है।
3. थ्री-वे प्राइमैलिटी ऑरेकल (Three-Way Primality Oracle): वर्तमान सेगमेंट में दिए गए सम संख्या $n$ $n$ और संभावित प्राइम $p$ $p$ के लिए, सिस्टम यह जाँचता है कि क्या $q = n - p$ $q = n - p$ अभाज्य है, जिसके लिए एक प्रायोरिटी चेन का उपयोग किया जाता है:
  - प्रायोरिटी 1: $q \le P_{SMALL}$ ( $10^6$ ): स्थायी रूप से निवासी छोटे-प्राइम बिटसेट (~122 KB) में लुकअप।
  - प्रायोरिटी 2: $q \in [A, B]$ (वर्तमान सेगमेंट): वर्तमान 14 MB सेगमेंट बिटसेट में लुकअप।
  - प्रायोरिटी 3: $P_{SMALL} < q < A$ : नियतात्मक (deterministic) 64-बिट मिलर-रबिन टेस्ट।
    यह डिज़ाइन सुनिश्चित करता है कि कुल रेंज $N$ के बावजूद VRAM का उपयोग $O(1)$ रहे, क्योंकि केवल वर्तमान सेगमेंट ही मेमोरी में रहता है।
फ़ालबैक और सत्यापन श्रृंखला (Fallback and Verification Chains):
- CPU फ़ालबैक: यदि चरण 1 (GPU) किसी भी $n$ के लिए विभाजन खोजने में विफल रहता है, तो एक कठोर CPU विस्तृत खोज (exhaustive search) शुरू की जाती है। सभी प्रयोगों में, इसे कभी भी कॉल नहीं किया गया।
- अनिश्चित परिशुद्धता (big_check): यह $10^{10,000}$ अंकों तक व्यक्तिगत संख्याओं को सत्यापित करने के लिए GMP और OpenMP के साथ एक सिंक्रोनाइज्ड बैच-सर्च रणनीति का उपयोग करता है, जो समानांतर निष्पादन में थ्रेड रनवे को रोकता है।

मुख्य योगदान (Key Contributions):

VRAM सीलिंग का उन्मूलन: सेगमेंटेड डबल-सीव डिज़ाइन मेमोरी बाधा को हटा देता है, जिससे एकल उपभोक्ता GPU (NVIDIA RTX 3070, 8 GB VRAM) पर $10^{12}$ तक पूर्ण सत्यापन संभव हो जाता है।
मेमोरी दक्षता: एक सघन बिटसेट प्रतिनिधित्व मेमोरी आवश्यकताओं को 16× कम करता है, जिससे $10^{11}$ तक की प्राइम टेबल को GPU-रेसिडेंट बनाना संभव होता है।
सत्यता की गारंटी: दो-चरणीय डिज़ाइन (GPU फास्ट-पाथ + CPU फ़ालबैक) न्यूनतम गोल्डबैक प्राइम की अपुष्ट सीमाओं पर निर्भर किए बिना गणितीय पूर्णता सुनिश्चित करता है।
स्केलेबिलिटी: फ्रेमवर्क डेटा-सेंटर हार्डवेयर (8× H100 पर परीक्षण किया गया) पर स्वच्छ मल्टी-जीपीयू स्केलिंग प्रदर्शित करता है और $10^{10,000}$ अंकों तक अनिश्चित परिशुद्धता सत्यापन का समर्थन करता है।
ओपन सोर्स: संपूर्ण कोडबेस ओपन-सोर्स, प्रलेखित और उपभोक्ता एवं उच्च-स्तरीय हार्डवेयर दोनों पर पुनरुत्पादनीय (reproducible) है।

4. परिणाम (Results)

सत्यापन रेंज: फ्रेमवर्क ने लगभग 41 मिनट में एक RTX 3070 पर $10^{12}$ तक की सभी सम संख्याओं को सफलतापूर्वक सत्यापित किया। कोई काउंटर-एग्जांपल नहीं पाया गया।
प्रदर्शन:
- स्पीडअप: $10^9$ पर, GPU कार्यान्वयन ने CPU बेसलाइन की तुलना में 16× स्पीडअप प्राप्त किया।
- स्केलिंग: रनटाइम रेंज के साथ रैखिक रूप से ( $O(N)$ ) स्केल करता है। सेगमेंटेड डिज़ाइन निरंतर प्रति-सेगमेंट लागत बनाए रखता है।
- मल्टी-जीपीयू: 6× RTX 3090 GPU पर स्ट्रॉन्ग स्केलिंग ने लगभग रैखिक दक्षता दिखाई (4 GPU पर 91%, 6 GPU पर 80%)।
न्यूनतम प्राइम बाउंड्स का अनुभवजन्य सत्यापन: पूरी $10^{12}$ रेंज में चरण 1 (केवल GPU) की 100% सफलता दर अनुभवजन्य रूप से पुष्टि करती है कि सभी $n \le 10^{12}$ के लिए न्यूनतम गोल्डबैक प्राइम $p_{min}(n) \le 2 \times 10^6$ है। यह सैद्धांतिक भविष्यवाणियों ( $H(10^{12}) \approx 2000$ ) के अनुरूप है।
अनिश्चित परिशुद्धता: 20 थ्रेड्स का उपयोग करके 182 सेकंड में एक 10,001-अंकों वाली संख्या ( $10^{10,000}$ ) को सत्यापित किया।

5. महत्व और सीमाएँ (Significance and Limitations)

महत्व:
यह कार्य सिद्ध करता है कि पूर्ववर्ती GPU गोल्डबैक सत्यापन की सीमाएँ वास्तुशिल्प संबंधी (मोनोलिथिक मेमोरी आवंटन) थीं, न कि मौलिक। इनवर्टेड वेरिफिकेशन लूप और सेगमेंटेड सीविंग का उपयोग करके, GoldbachGPU गोल्डबैक सत्यापन का लोकतंत्रीकरण करता है, जिससे एक एकल उपभोक्ता कार्ड को पिछले एकल-जीपीयू प्रयासों की तुलना में एक क्रम (order of magnitude) बेहतर प्रदर्शन करने की अनुमति मिलती है। यह कमोडिटी हार्डवेयर और ऐसे कार्यों के लिए आवश्यक विशाल वितरित क्लस्टरों के बीच के अंतर को पाटता है।

सीमाएँ और भविष्य का कार्य:

CPU बॉटलनेक: वर्तमान कार्यान्वयन CPU-आधारित सेगमेंटेड सीव निर्माण द्वारा सीमित है, जिसे GPU ट्रांसफर से पहले प्राइम टेबल उत्पन्न करनी होती है। उच्च-स्तरीय हार्डवेयर (H100) पर, GPU अक्सर डेटा फीड करने के लिए CPU का इंतज़ार करते हुए खाली रहता है।
एल्गोरिद्मिक गैप: वर्तमान दृष्टिकोण प्रति- $n$ प्राइमैलिटी लुकअप करता है। लेखक पहचानते हैं कि एक बिटवाइज़ बल्क-मार्किंग कर्नेल (पूर्ण डबल-सीव विधि के समान) को अपनाने से जटिलता को $O(N \log \log N)$ तक कम किया जा सकता है और मिलर-रबिन फ़ालबैक को समाप्त किया जा सकता है, जो संभावित रूप से एकल GPU पर सत्यापन को $10^{15}$ तक धकेल सकता है।
मेमोरी बैंडविड्थ: प्रदर्शन होस्ट मेमोरी बैंडविड्थ के प्रति संवेदनशील है; बड़े सेगमेंट उच्च-बैंडविड्थ वाले GPU को भूखा रख सकते हैं यदि होस्ट CPU डेटा को तेज़ी से भेजने में सक्षम नहीं है।

निष्कर्षतः, GoldbachGPU कम्प्यूटेशनल नंबर थ्योरी में एक महत्वपूर्ण छलांग का प्रतिनिधित्व करता है, जो व्यापक रूप से सुलभ हार्डवेयर पर गोल्डबैक अनुमान को सत्यापित करने के लिए एक स्केलेबल, ओपन और कठोर फ्रेमवर्क प्रदान करता है।