गणित・क्रिप्टोग्राफी・क्वांटम on kenji.blog

【पूर्ण विश्लेषण】 क्वांटम कंप्यूटर क्या है? ~ शून्य से समझें परम गणना सिद्धांत ~

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

परिचय: क्वांटम कंप्यूटर द्वारा लाया गया “गणना का प्रतिमान बदलाव”

हाल के वर्षों में, ऐसा कोई दिन नहीं जाता जब हम समाचारों या तकनीकी लेखों में “क्वांटम कंप्यूटर” शब्द न देखें। साइंस फिक्शन फिल्मों जैसी कहानियाँ जैसे “यह उन गणनाओं को कुछ मिनटों में पूरा कर लेगा जिनमें वर्तमान सुपरकंप्यूटरों को हजारों साल लगेंगे” या “वर्तमान की सभी क्रिप्टोग्राफ़िक तकनीकें टूट सकती हैं”, सच के रूप में बताई जा रही हैं। Google, IBM और Microsoft जैसी विशाल IT कंपनियों से लेकर दुनिया भर के विश्वविद्यालयों और स्टार्टअप्स तक, हर कोई इस सपनों की तकनीक को व्यावहारिक बनाने के लिए प्रतिस्पर्धा कर रहा है।

हालाँकि, जब पूछा जाता है, “आख़िर क्वांटम कंप्यूटर क्या है?”, तो बहुत कम लोग सटीक उत्तर दे पाते हैं। बहुत से लोगों के मन में “एक जादुई डिब्बा जो एक ही समय में सभी संयोजनों की गणना कर सकता है” जैसी एक अस्पष्ट छवि होती है, लेकिन तकनीकी रूप से यह सही नहीं है।

इस लेख में, हम बुनियादी बातों से पूरी तरह से, पेशेवर लेकिन समझने में आसान तरीके से समझाएंगे कि क्वांटम कंप्यूटर मौलिक रूप से शास्त्रीय कंप्यूटरों (हम आमतौर पर उपयोग किए जाने वाले PC या स्मार्टफोन) से कैसे भिन्न हैं, और वे गणना के लिए “सुपरपोजिशन (Superposition)”, “क्वांटम उलझाव (Entanglement)” और “क्वांटम गेट्स (Quantum gates)” जैसी रहस्यमय क्वांटम यांत्रिक घटनाओं का उपयोग कैसे करते हैं। जब तक आप इस लेख को पढ़ना समाप्त करेंगे, तब तक आपको क्वांटम कंप्यूटर की वास्तविक शक्ति और इसकी वर्तमान चुनौतियों को स्पष्ट रूप से समझ लेना चाहिए।

अध्याय 1: शास्त्रीय कंप्यूटर और क्वांटम कंप्यूटर के बीच निर्णायक अंतर

क्वांटम कंप्यूटर कैसे काम करते हैं, यह समझने के लिए, हमें पहले यह समीक्षा करनी होगी कि हम वर्तमान में जिन “शास्त्रीय कंप्यूटरों” का उपयोग करते हैं वे कैसे काम करते हैं।

तुलना तालिका: शास्त्रीय कंप्यूटर बनाम क्वांटम कंप्यूटर

विशेषता	शास्त्रीय कंप्यूटर	क्वांटम कंप्यूटर
मूल इकाई	बिट (0 या 1)	क्वांटम बिट (0 और 1 का सुपरपोजिशन)
स्थिति का प्रतिनिधित्व	नियतात्मक	संभाव्य (जब तक देखा न जाए तब तक निर्धारित नहीं)
गणना विधि	अनुक्रमिक प्रसंस्करण (समानांतरीकरण के लिए भौतिक कोर की आवश्यकता है)	क्वांटम समानांतरवाद (समानांतर में घातीय स्थितियों में हेरफेर)
इसमें अच्छा है	अंकगणितीय संचालन, दैनिक डेटा प्रसंस्करण	अभाज्य गुणनखंडन, क्वांटम रसायन गणना
त्रुटि सहिष्णुता	बहुत मजबूत	बहुत कमजोर (क्रायोजेनिक वातावरण और त्रुटि सुधार की आवश्यकता है)

शास्त्रीय कंप्यूटरों की दुनिया: 0 या 1 का “बिट (Bit)”

एक शास्त्रीय कंप्यूटर सभी सूचनाओं को “0” या “1” की स्थिति के रूप में दर्शाता है। इसे बिट (Bit) कहा जाता है। भौतिक रूप से, इसे अर्धचालक चिप पर ट्रांजिस्टर के उच्च (1) या निम्न (0) वोल्टेज द्वारा दर्शाया जाता है। आपके स्मार्टफोन में उच्च-रिज़ॉल्यूशन वाली तस्वीरें, आपके द्वारा अभी पढ़ा जा रहा यह पाठ, और आपके पसंदीदा YouTube वीडियो सभी अंततः “0 और 1 के अनुक्रमों” की एक विशाल संख्या में कम हो जाते हैं। गणना इस 0 और 1 के अनुक्रम में AND, OR और NOT जैसे बुनियादी तार्किक सर्किटों को मिलाकर संचालन लागू करने की प्रक्रिया के अलावा और कुछ नहीं है। यह एक बहुत ही निश्चित और नियतात्मक दुनिया है। यदि इनपुट समान है, तो आउटपुट हमेशा समान होगा।

क्वांटम कंप्यूटरों की दुनिया: 0 और 1 का “क्वांटम बिट (Qubit)”

दूसरी ओर, एक क्वांटम कंप्यूटर की न्यूनतम सूचना इकाई को क्वांटम बिट (Qubit: Quantum bit) कहा जाता है। क्वांटम बिट की सबसे बड़ी विशेषता यह है कि यह केवल एक शास्त्रीय बिट की तरह “0” या “1” स्थिति में नहीं होता है, बल्कि “ऐसी स्थिति में होता है जहां 0 और 1 एक विशिष्ट संभाव्यता के साथ मिश्रित होते हैं”। इसे “सुपरपोजिशन (Superposition)” कहा जाता है।

उदाहरण के लिए, यदि एक शास्त्रीय बिट एक सिक्का है जिसे “चित” या “पट” के साथ रखा जाता है, तो एक क्वांटम बिट की तुलना अक्सर “हवा में घूमते हुए सिक्के” से की जाती है। एक घूमते हुए सिक्के को न तो चित कहा जा सकता है और न ही पट, और दोनों स्थितियां सुपरइम्पोज़ (अतिव्यापी) होती हैं। फिर, जिस क्षण सिक्का फर्श पर गिरता है और चलना बंद कर देता है (इसे क्वांटम यांत्रिकी में “अवलोकन” कहा जाता है), यह पहली बार निर्धारित होता है कि यह “चित” या “पट”।

क्वांटम कंप्यूटर इस गुण को शामिल करते हैं, जो सूक्ष्म दुनिया (क्वांटम यांत्रिकी) के लिए अद्वितीय है, जहां “स्थिति तब तक निर्धारित नहीं होती है जब तक कि यह अवलोकन न किया जाए”, सीधे सूचना प्रसंस्करण प्रक्रिया में।

अध्याय 2: 3 क्वांटम यांत्रिक गुण जो मौलिक रूप से गणना को बदलते हैं

क्वांटम कंप्यूटरों की अद्भुत गणना शक्ति का स्रोत केवल उच्च क्लॉक आवृत्ति या छोटे घटकों का होना नहीं है। यह इस तथ्य में निहित है कि वे भौतिकी के नियमों का उपयोग गणना संसाधनों के रूप में करते हैं। निम्नलिखित तीन क्वांटम यांत्रिक घटनाएं मुख्य कुंजियां हैं।

1. सुपरपोजिशन (Superposition) और घातीय सूचना मात्रा

जैसा कि पहले उल्लेख किया गया জ্ঞ, क्वांटम बिट्स एक ही समय में 0 और 1 दोनों स्थितियों को पकड़ सकते हैं। एक क्वांटम बिट “0 और 1 का सुपरपोजिशन” है, लेकिन क्या होता है जब आप क्वांटम बिट्स की संख्या बढ़ाते हैं?

1 क्वांटम बिट: 2 स्थितियों का सुपरपोजिशन (0, 1)
2 क्वांटम बिट्स: 4 स्थितियों का सुपरपोजिशन (00, 01, 10, 11)
3 क्वांटम बिट्स: 8 स्थितियों का सुपरपोजिशन
N क्वांटम बिट्स: $2^N$ पैटर्न का सुपरपोजिशन

केवल 50 क्वांटम बिट्स के साथ, आप एक ही समय में $2^{50}$ (लगभग 1.1 क्वाड्रिलियन) स्थितियों को धारण कर सकते हैं। और केवल 300 क्वांटम बिट्स के साथ, आप एक ही समय में $2^{300}$ पैटर्न (ब्रह्मांड में सभी परमाणुओं की संख्या से अधिक!) धारण कर सकते हैं। यह घातीय सूचना प्रतिधारण क्षमता क्वांटम कंप्यूटरों की क्षमता का आधार है। एक शास्त्रीय कंप्यूटर के लिए स्मृति में ब्रह्मांड में परमाणुओं की संख्या से अधिक स्थितियों को संग्रहीत करना भौतिक रूप से असंभव है।

2. क्वांटम उलझाव (Entanglement): डरावनी दूर की कार्रवाई

क्वांटम उलझाव एक अजीब घटना है जो मानवीय अंतर्ज्ञान के इतनी खिलाफ है कि आइंस्टीन ने इसे “दूरी पर डरावनी कार्रवाई (Spooky action at a distance)” कहा और इसे जीवन भर स्वीकार नहीं किया।

जब कई क्वांटम बिट्स “क्वांटम उलझाव” की स्थिति में प्रवेश करते हैं, तो वे एक-दूसरे से मजबूती से बंध जाते हैं, और एक भाग्य-साझा करने वाला रिश्ता बन जाता है जहां “जब एक की स्थिति निर्धारित होती है, तो दूसरे की स्थिति तुरंत निर्धारित हो जाती है, चाहे वे कितनी भी दूर हों” ।

उदाहरण के लिए, मान लीजिए कि हमारे पास दो क्वांटम बिट्स A और B हैं जो उलझी हुई अवस्था में हैं (वे प्रत्येक 0 और 1 की सुपरपोजिशन स्थिति में हैं)। यदि हम A का अवलोकन करते हैं और पाते हैं कि यह “0” है, तो प्रकाश की गति से अधिक गति से, जो सूचना संचरण की सीमा है, B की स्थिति तुरंत निर्धारित हो जाएगी (उदाहरण के लिए, यह हमेशा “1” होगा)। क्वांटम कंप्यूटरों में, इस क्वांटम उलझाव का उपयोग कई क्वांटम बिट्स के बीच जटिल सहसंबंधों को व्यक्त करने और बड़े पैमाने पर समानांतर सूचना प्रसंस्करण करने के लिए किया जाता है। उलझाव के बिना, क्वांटम कंप्यूटरों की कम्प्यूटेशनल शक्ति शास्त्रीय कंप्यूटरों से बहुत अलग नहीं होगी।

3. क्वांटम हस्तक्षेप (Quantum Interference): वह जादू जो सही उत्तर को सामने लाता है

आप सोच सकते हैं, “यदि यह एक ही समय में सभी पैटर्नों को धारण कर सकता है, तो क्या यह एक ही बार में समानांतर में गणना नहीं कर सकता है और तुरंत उत्तर प्राप्त नहीं कर सकता है?” यह क्वांटम कंप्यूटरों के बारे में सबसे आम गलतफहमी है। भले ही आप सुपरपोजिशन अवस्था में गणना करते हैं, अंततः उत्तर जानने के लिए आपको “अवलोकन” करना होगा। हालाँकि, जिस क्षण आप इसका अवलोकन करते हैं, स्थिति यादृच्छिक रूप से $2^N$ पैटर्न में से एक में ढह जाती है। इसके साथ, आपको केवल एक यादृच्छिक (random) उत्तर मिलता है।

यहीं पर “क्वांटम हस्तक्षेप (Interference)” खेल में आता है। जब तरंगें एक-दूसरे से टकराती हैं, तो वे एक-दूसरे को मजबूत करती हैं जहां उनकी तरंग दैर्ध्य मेल खाती है, और जहां वे संरेखण से बाहर होती हैं वहां एक-दूसरे को रद्द कर देती हैं (यह अनिवार्य रूप से शोर-रद्द करने वाले इयरफ़ोन के समान सिद्धांत है)।

एक उत्कृष्ट “क्वांटम एल्गोरिथ्म” गणना प्रक्रिया के दौरान चतुराई से क्वांटम स्थितियों में हेरफेर करता है ताकि “उन स्थितियों (तरंगों) के संभाव्यता आयामों को बढ़ाया जा सके जो सही उत्तर की ओर ले जाते हैं” और “उन स्थितियों के संभाव्यता आयामों को रद्द किया जा सके जो गलत उत्तर की ओर ले जाते हैं” । और जब आप अंततः इसका अवलोकन करते हैं, तो यह ऐसा करता है कि “सही उत्तर” लगभग 100% की संभावना के साथ निकल आता है। इस हस्तक्षेप प्रक्रिया को सफलतापूर्वक डिज़ाइन करना क्वांटम प्रोग्रामिंग का सार है।

अध्याय 3: यह गणना कैसे करता है? “क्वांटम गेट्स” और “क्वांटम सर्किट”

जिस तरह शास्त्रीय कंप्यूटर गणना को आगे बढ़ाने के लिए लॉजिक गेट्स (AND, OR, NOT, आदि) का उपयोग करते हैं, उसी तरह क्वांटम कंप्यूटर भी गणना को आगे बढ़ाने के लिए क्वांटम बिट्स पर “क्वांटम गेट्स (Quantum Gates)” नामक संचालन लागू करते हैं। कई क्वांटम गेट्स के संयोजन को ** क्वांटम सर्किट (Quantum Circuit) ** कहा जाता है।

क्वांटम बिट की स्थिति को गणितीय रूप से 3-आयामी क्षेत्र की सतह पर एक बिंदु के रूप में दर्शाया जाता है जिसे “बलोच क्षेत्र (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 गेट (नियंत्रित NOT गेट)

क्वांटम उलझाव बनाने के लिए यह एक अति-महत्वपूर्ण गेट है। यह दो क्वांटम बिट्स (नियंत्रण बिट और लक्ष्य बिट) का उपयोग करता है। यह इस तरह से काम करता है: “यदि नियंत्रण बिट 1 है, तो लक्ष्य बिट की स्थिति उलट जाती है (X गेट)। यदि नियंत्रण बिट 0 है, तो यह कुछ नहीं करता है।” पहली नज़र में, यह एक साधारण IF शर्त शाखा की तरह लगता है, लेकिन क्या होता है यदि नियंत्रण बिट “0 और 1 की सुपरपोजिशन स्थिति” में है? लक्ष्य बिट “उलटे और बिना उलटे का सुपरपोजिशन स्थिति” में होगा, और दोनों बिट्स का भाग्य पूरी तरह से जुड़ जाएगा। दो क्वांटम बिट्स खूबसूरती से “उलझ (entangled)” जाते हैं।

इन गेट्स को संगीत स्कोर की तरह बाएं से दाएं क्रम में रखकर और लागू करके, जटिल एल्गोरिदम निष्पादित किए जाते हैं।

अध्याय 4: क्वांटम कंप्यूटर किसमें अच्छे हैं और किसमें खराब?

यहां एक महत्वपूर्ण तथ्य बताया गया है: क्वांटम कंप्यूटर सर्वशक्तिमान ईश्वर नहीं हैं। हर रोज़ के कामों जैसे वेब ब्राउज़िंग, वीडियो रेंडरिंग, एक्सेल मैक्रो प्रोसेसिंग, या सामान्य स्मार्टफोन ऐप ऑपरेशंस में, क्वांटम कंप्यूटर शायद कभी भी शास्त्रीय कंप्यूटरों को पार नहीं कर पाएंगे। ये अनुक्रमिक प्रक्रियाएँ पहले से ही अत्यधिक अनुकूलित हैं, और भारी गति और सस्तेपन का दावा करने वाले शास्त्रीय कंप्यूटर इनके लिए अधिक उपयुक्त हैं।

क्वांटम कंप्यूटरों का वास्तविक मूल्य केवल “विशिष्ट समस्याओं के लिए महसूस किया जाता है जहां शास्त्रीय कंप्यूटरों में गणना संयोजनों की संख्या तेजी से बढ़ती है, और ब्रह्मांड के जीवनकाल जितना समय लगता है” । इसे “क्वांटम सर्वोच्चता (Quantum Supremacy)” या “क्वांटम लाभ (Quantum Advantage)” कहा जाता है।

क्वांटम कंप्यूटर किसमें अच्छे हैं (किलर एप्लिकेशन)

1. अभाज्य गुणनखंडन और डिक्रिप्शन (शोर का एल्गोरिथ्म)

वर्तमान में, इंटरनेट पर सुरक्षित संचार (क्रेडिट कार्ड से भुगतान और व्यक्तिगत जानकारी का प्रसारण आदि) की रक्षा करने वाला “RSA क्रिप्टोग्राफी” इस आधार पर आधारित है कि “शास्त्रीय कंप्यूटरों के लिए बड़ी संख्याओं का अभाज्य गुणनखंडन व्यावहारिक रूप से असंभव है (इसमें बहुत समय लगता है)"। हालाँकि, 1994 में गणितज्ञ पीटर शोर द्वारा खोजे गए “शोर के एल्गोरिथ्म” का उपयोग करके, एक क्वांटम कंप्यूटर बड़ी चतुराई से हस्तक्षेप का उपयोग करके नाटकीय गति (बहुपद समय) से इसे हल कर सकता है। इसके परिणामस्वरूप, भविष्य में वर्तमान क्रिप्टोग्राफ़िक प्रणाली के ढहने का जोखिम है, और दुनिया भर के केंद्रीय बैंक और सरकारी एजेंसियां “क्वांटम-प्रतिरोधी क्रिप्टोग्राफी (Post-Quantum Cryptography)” में संक्रमण के लिए जल्दबाजी कर रही हैं।

2. क्वांटम रासायनिक गणना और नई सामग्री/दवा विकास

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

3. संयोजन अनुकूलन समस्याएं और खोज (ग्रोवर का एल्गोरिथ्म)

विकल्पों की एक विशाल संख्या (लॉजिस्टिक्स ऑप्टिमाइज़ेशन रूट, वित्तीय पोर्टफोलियो ऑप्टिमाइज़ेशन, आदि) से सर्वश्रेष्ठ को खोजने की समस्या के लिए भी, क्वांटम एल्गोरिदम अपनी शक्ति दिखाते हैं। “ग्रोवर के एल्गोरिथ्म” का उपयोग करके, आप असंरचित डेटाबेस से शास्त्रीय कंप्यूटर के वर्गमूल (स्क्वायर रूट) के समय में वांछित डेटा पा सकते हैं। उदाहरण के लिए, यदि 100 मिलियन डेटा आइटम हैं, तो एक शास्त्रीय कंप्यूटर जिसे खोजने में 100 मिलियन बार तक का समय लगता है, उसे केवल 10,000 बार में पूरा किया जा सकता है।

अध्याय 5: हार्डवेयर की दीवार जो रास्ते में खड़ी है: “डिकोहेरेंस” और “क्वांटम त्रुटि सुधार”

हालांकि सैद्धांतिक रूप से जादुई रूप से शक्तिशाली, क्वांटम कंप्यूटरों के व्यावहारिक अनुप्रयोग के रास्ते में एक बहुत ही उच्च और खड़ी भौतिक दीवार है। सबसे बड़ा दुश्मन “शोर (Noise)” है।

क्वांटम बिट्स का “सुपरपोजिशन” और “क्वांटम उलझाव” बेहद नाजुक और नाजुक अवस्थाएँ हैं। बस परिवेशी गर्मी, विद्युत चुम्बकीय उतार-चढ़ाव, या कॉस्मिक किरणों को छूने से, जादुई स्थिति तुरंत ढह जाती है और केवल एक शास्त्रीय बिट बन जाती है। इस घटना को “डिकोहेरेंस (क्वांटम पतन)” कहा जाता है।

भौतिक प्राप्ति विधियों के लिए भयंकर प्रतिस्पर्धा

वर्तमान में, इन नाजुक क्वांटम बिट्स को भौतिक रूप से कैसे बनाया जाए, इस पर दुनिया भर में विभिन्न तरीकों पर शोध किया जा रहा है, और वर्चस्व की लड़ाई हो रही है।

सुपरकंडक्टिंग विधि (Superconducting) : Google, IBM, Amazon, आदि द्वारा अपनाया गया। एक लूप-आकार के सुपरकंडक्टिंग सर्किट का उपयोग किया जाता है, और क्वांटम स्थिति को नियंत्रित करने के लिए इसे एक विशाल रेफ्रिजरेटर के साथ पूर्ण शून्य (लगभग -273°C) के करीब क्रायोजेनिक तापमान तक ठंडा किया जाता है। यह वर्तमान में सबसे अग्रणी तरीका है और क्वांटम बिट्स की संख्या बढ़ाना आसान है, लेकिन शीतलन उपकरण बहुत बड़ा और महंगा है।
आयन ट्रैप विधि (Trapped Ion) : IonQ, Quantinuum, आदि द्वारा अपनाया गया। आयनों (परमाणुओं) को विद्युत चुम्बकीय क्षेत्रों का उपयोग करके निर्वात में फंसाया जाता है, और उन्हें नियंत्रित करने के लिए सटीक लेजर लागू किए जाते हैं। ताकत यह है कि सभी क्वांटम बिट्स एक समान हैं और स्थिति को लंबे समय तक बनाए रखा जा सकता है (लंबा सुसंगतता समय), लेकिन चुनौती यह है कि संचालन की गति सुपरकंडक्टिंग विधि की तुलना में धीमी है।
ऑप्टिकल क्वांटम विधि (Photonic) : PsiQuantum, आदि द्वारा केंद्रित। प्रकाश के कणों (फोटोन) का उपयोग किया जाता है। क्रायोजेनिक वातावरण की आवश्यकता नहीं होती है और कई हिस्से कमरे के तापमान पर काम বৃহত্তর करते हैं, जिसका बड़ा फायदा मौजूदा सिलिकॉन चिप निर्माण तकनीक और ऑप्टिकल फाइबर संचार तकनीक के अनुकूल होना है।
टोपोलॉजिकल विधि (Topological) : माइक्रोसॉफ्ट द्वारा कई वर्षों तक शोध किया गया। यह एनीन्स नामक विशेष कणों के टोपोलॉजिकल (टॉपोलॉजिकल) गुणों का उपयोग करके क्वांटम बिट्स बनाने का एक महत्वाकांक्षी दृष्टिकोण है जो पर्यावरणीय शोर के लिए मौलिक रूप से प्रतिरोधी हैं (त्रुटियों का खतरा कम)। इसे सिद्धांत रूप में सबसे मजबूत माना जाता है, लेकिन भौतिक प्राप्ति के लिए सबसे अधिक बाधाओं वाला माना जाता है।

अंतिम लक्ष्य का मार्ग: “फॉल्ट-टॉलरेंट क्वांटम कंप्यूटर (FTQC)”

वर्तमान शास्त्रीय कंप्यूटर दुनिया में भी गणना त्रुटियां (जैसे कॉस्मिक किरणों के कारण बिट फ़्लिप) मौजूद हैं, लेकिन उन्हें “त्रुटि सुधार कोड” द्वारा पूरी तरह से ठीक किया जाता है, इसलिए हम बिना किसी त्रुटि के अपने स्मार्टफोन का उपयोग कर सकते हैं। क्वांटम कंप्यूटरों में व्यावहारिक बड़े पैमाने पर गणना करने के लिए, इसी तरह का “क्वांटम त्रुटि सुधार (Quantum Error Correction: QEC)” आवश्यक है।

हालाँकि, चूंकि क्वांटम स्थितियों में “अवलोकन किए जाने पर टूटने” की संपत्ति होती है, इसलिए एक घातक दुविधा है कि आप त्रुटियों की जांच करने के लिए सीधे अंदर नहीं देख सकते (निरीक्षण नहीं कर सकते)। इससे बचने के लिए, त्रुटियों का पता लगाने और उन्हें ठीक करने के लिए एक स्थिर “तार्किक क्वांटम बिट” बनाने के लिए कई अस्थिर “भौतिक क्वांटम बिट्स” को चतुराई से संयोजित करने का एक सिद्धांत स्थापित किया गया है (जैसे सतह कोड)। हालाँकि, कहा जाता है कि एक तार्किक क्वांटम बिट बनाने के लिए 1,000 से 10,000 भौतिक क्वांटम बिट्स की आवश्यकता होती है। शोर के एल्गोरिथ्म आदि को निष्पादित करने के लिए हजारों तार्किक क्वांटम बिट्स का उपयोग करने के लिए, कुल लाखों से करोड़ों भौतिक क्वांटम बिट्स के साथ एक विशाल प्रणाली की आवश्यकता होगी।

हम वर्तमान में जिसे NISQ (Noisy Intermediate-Scale Quantum: शोर मध्यवर्ती-पैमाने क्वांटम) उपकरणों का युग कहा जाता है, उसमें हैं। ये संक्रमणकालीन मशीनें हैं जो बिना त्रुटि सुधार के दसियों से सैकड़ों क्वांटम बिट्स के साथ काम करती हैं। विशेषज्ञों का अनुमान है कि “फॉल्ट-टॉलरेंट क्वांटम कंप्यूटर (Fault-Tolerant Quantum Computer: FTQC)” के अंतिम लक्ष्य को साकार करने में अभी भी 10 से कई दशक लंबी अवधि के अनुसंधान और विकास की आवश्यकता है, जो पूरी तरह से त्रुटि-सुधारने में सक्षम है।

अध्याय 6: क्वांटम कंप्यूटरों का इतिहास और भविष्य की संभावनाएं

अंत में, आइए एक नजर डालते हैं कि क्वांटम कंप्यूटर कैसे पैदा हुए और वे भविष्य में कहां जा रहे हैं।

सिद्धांत के जन्म से लेकर “क्वांटम सर्वोच्चता” के प्रदर्शन तक

1980 का दशक : भौतिक विज्ञानी पॉल बेनियोफ और रिचर्ड फेनमैन ने क्वांटम यांत्रिकी के सिद्धांतों का उपयोग करते हुए एक कंप्यूटर की अवधारणा का प्रस्ताव रखा। “यदि आप प्रकृति का अनुकरण करना चाहते हैं, तो क्वांटम यांत्रिकी का उपयोग करें” शब्द शुरुआती बिंदु थे।
1994 : पीटर शोर ने अभाज्य गुणनखंडन (शोर का एल्गोरिथ्म) के लिए एक क्वांटम एल्गोरिथ्म प्रकाशित किया। इसने दुनिया को चौंका दिया और बड़ी मात्रा में शोध निधि प्रवाहित होने लगी।
1996 : लव ग्रोवर ने ग्रोवर का एल्गोरिथ्म प्रकाशित किया, जो डेटा खोजों को गति देता है।
**2019 ** : एक ऐतिहासिक मील का पत्थर। Google ने घोषणा की कि उसने अपने 53-क्विबिट सुपरकंडक्टिंग प्रोसेसर “Sycamore” का उपयोग करके लगभग 200 सेकंड में एक यादृच्छिक संख्या जनरेशन सत्यापन गणना पूरी की है जिसे एक शास्त्रीय सुपरकंप्यूटर पर 10,000 वर्ष लगने की उम्मीद थी। इसने दुनिया की पहली “क्वांटम सर्वोच्चता (Quantum Supremacy)” के प्रदर्शन के रूप में बहुत ध्यान आकर्षित किया (बाद में, IBM और अन्य ने शास्त्रीय सुपरकंप्यूटर पक्ष पर एल्गोरिथ्म में सुधार किया और तर्क दिया कि इसकी गणना कुछ ही दिनों में की जा सकती है, जिससे एक गर्म बहस छिड़ गई)।
2023 और उसके बाद : IBM ने 1,000 से अधिक क्वांटम बिट्स के साथ “Condor” प्रोसेसर की घोषणा की। इसके अलावा, हार्वर्ड विश्वविद्यालय और अन्य ने “तार्किक क्वांटम बिट्स” बनाने और हेरफेर करने में सफलता प्राप्त की है, और त्रुटि सुधार तकनीक के प्रारंभिक प्रदर्शनों की एक के बाद एक रिपोर्ट की जा रही है।

अगली पीढ़ी की प्रौद्योगिकी की ओर

एक क्वांटम कंप्यूटर केवल “तेज घड़ी गति वाला अगली पीढ़ी का CPU” नहीं है। यह गणना की अवधारणा को मौलिक रूप से फिर से लिखता है, क्वांटम यांत्रिकी के नियमों का उपयोग करके जो सूक्ष्म दुनिया को नियंत्रित करता है, सूचना विज्ञान में एक वास्तविक प्रतिमान बदलाव है।

शायद हमारे जीवनकाल में हमारे पास “व्यक्तिगत क्वांटम स्मार्टफोन” नहीं होंगे जो हमारी जेब में फिट हो सकें (इसकी कोई आवश्यकता भी नहीं है)। हालाँकि, वह भविष्य निश्चित रूप से करीब आ रहा है जहाँ AWS या Azure जैसे क्लाउड नेटवर्क के पीछे एक शक्तिशाली क्वांटम डेटा सेंटर अचानक एक लाइलाज बीमारी का इलाज खोज लेता है, या एक स्वप्निल स्वच्छ ऊर्जा सामग्री का पता लगाता है जो ग्लोबल वार्मिंग को हल करती है (उदाहरण के लिए, एक उत्प्रेरक जो कमरे के तापमान पर वायुमंडलीय नाइट्रोजन से अमोनिया को संश्लेषित करता है)।

अब हम एक प्रारंभिक चरण में हैं जो 1940 के दशक में विशाल वैक्यूम ट्यूबों की गर्मी से उबलते हुए कमरों में पंच कार्डों पर चलने वाले ENIAC के बराबर है। हालाँकि, दुनिया भर के शीर्ष स्तर के शोधकर्ता और इंजीनियर अपनी बुद्धि लगा रहे हैं, और हर दिन तकनीकी सफलताओं की सूचना दी जा रही है। इस नए “गणना की सुबह” के विकास के गवाह बन सकने वाले हम कह सकते हैं कि हम इतिहास के एक बहुत ही रोमांचक दौर में जी रहे हैं।

क्वांटम दुनिया के दरवाजे अभी खुले हैं। हम भविष्य के रुझानों पर नज़र रखना जारी रखेंगे।

इस लेख का उद्देश्य व्यावसायिक पेशेवरों और प्रौद्योगिकी में रुचि रखने वाले आम लोगों के लिए क्वांटम कंप्यूटिंग की बुनियादी अवधारणाओं को आसानी से समझने वाले तरीके से समझाना है। कृपया ध्यान दें कि कुछ सख्त गणितीय और भौतिक परिभाषाओं (जैसे ब्रा-केट नोटेशन और जटिल संभाव्यता आयामों का विवरण) को कुछ हद तक सरल बनाया गया है।

क्या क्वांटम कंप्यूटर वास्तव में RSA एन्क्रिप्शन को नष्ट कर देगा? ~ शोर का एल्गोरिदम और वर्तमान स्थिति ~

Sat, 05 Sep 2026 22:09:21 +0900

परिचय: क्रिप्टोग्राफी और क्वांटम कंप्यूटर का प्रतिच्छेदन

आधुनिक इंटरनेट समाज में, “सार्वजनिक-कुंजी क्रिप्टोग्राफी” (Public-key cryptography) संचार की गोपनीयता की रक्षा के लिए नींव के रूप में कार्य करती है। उनमें से सबसे प्रसिद्ध “RSA एन्क्रिप्शन” है, जिसे 1977 में रॉन रिवेस्ट, आदि शमीर और लियोनार्ड एडलमैन द्वारा विकसित किया गया था। ऑनलाइन शॉपिंग भुगतान, वेबसाइट ब्राउज़िंग (HTTPS) और हर दिन हमारे द्वारा उपयोग किए जाने वाले ईमेल भेजने और प्राप्त करने से लेकर, RSA एन्क्रिप्शन इंटरनेट बुनियादी ढांचे के दिल के रूप में कार्य करता है।

हालाँकि, “क्वांटम कंप्यूटर” के आगमन के साथ, यह बताया गया है कि इस सुरक्षा को मूल रूप से उखाड़ फेंका जा सकता है। मीडिया में अक्सर सनसनीखेज सुर्खियां होती हैं जैसे “एक बार क्वांटम कंप्यूटर पूरा हो जाने पर, दुनिया भर के पासवर्ड और एन्क्रिप्शन सेकंडों में डिक्रिप्ट हो जाएंगे।” क्या वह सच में सच है?

इस लेख में, हम GNFS (जनरल नंबर फील्ड सीव), एक क्लासिकल डिक्रिप्शन विधि, और “शोर का एल्गोरिदम” (Shor’s Algorithm) के तंत्र में गहराई से उतरेंगे, जो क्वांटम कंप्यूटर का उपयोग करके एक निश्चित डिक्रिप्शन एल्गोरिदम है। हम क्वांटम फूरियर ट्रांसफॉर्म और अवधि खोज जैसी उन्नत अवधारणाओं को आसानी से समझने वाले तरीके से समझाएंगे, और वर्तमान NISQ (Noisy Intermediate-Scale Quantum) युग में क्वांटम हार्डवेयर की वर्तमान स्थिति और RSA-2048 को क्रैक करने के लिए आवश्यक बाधाओं की विस्तार से जांच करेंगे।

RSA एन्क्रिप्शन का आधार: अभाज्य गुणनखंडन की कठिनाई

RSA एन्क्रिप्शन की सुरक्षा गणित में एक अत्यंत सरल विषमता (asymmetry) पर निर्भर करती है। तथ्य यह है कि “दो विशाल अभाज्य संख्याओं (prime numbers) को गुणा करना आसान है, लेकिन परिणाम (समग्र संख्या) से मूल दो अभाज्य संख्याओं को खोजना (अभाज्य गुणनखंडन) बेहद मुश्किल है।”

उदाहरण के लिए, मान लीजिए कि हमारे पास दो अभाज्य संख्याएं हैं $ p = 61 $ और $ q = 53 $। इस गुणा $ N = p \times q = 3233 $ की गणना करना तात्कालिक है। हालाँकि, यदि आपको केवल संख्या “3233” दी गई है और पूछा गया है “यह किन अभाज्य संख्याओं का गुणनफल है?”, तो संख्या के बड़े होने पर गणना की मात्रा विस्फोटक रूप से बढ़ जाती है।

वर्तमान मुख्यधारा RSA-2048 में, 2048 बिट्स की कुंजी लंबाई का उपयोग किया जाता है, जो दशमलव में लगभग 617 अंकों की एक विशाल समग्र संख्या $ N $ है। यदि इस $ N $ का अभाज्य गुणनखंडन किया जा सकता है, तो एन्क्रिप्शन लगभग टूट गया है।

क्लासिकल कंप्यूटरों द्वारा चुनौती: GNFS (सामान्य संख्या क्षेत्र चलनी)

गणितज्ञों और क्रिप्टोग्राफरों ने अभाज्य गुणनखंडन समस्या को हल करने के लिए वर्षों से विभिन्न एल्गोरिदम विकसित किए हैं। उनमें से, वर्तमान में क्लासिकल कंप्यूटरों पर सबसे तेज़ सामान्य संख्या क्षेत्र चलनी (GNFS: General Number Field Sieve) माना जाता है।

GNFS एक बड़ी संख्या $ N $ का गुणनखंडन करने के लिए पूर्णांक वलय में गणना को अधिक अमूर्त बीजगणितीय संख्या क्षेत्र (Number Field) में विस्तारित करके विश्लेषण करने की एक विधि है। मोटे तौर पर प्रक्रिया इस प्रकार है:

बहुपद का चयन : उचित घात और गुणांक वाला एक बहुपद $ f(x) $ खोजें जिसका मूल $ N $ हो।
डेटा संग्रह (छानना) : परिमेय और बीजगणितीय संख्या क्षेत्रों पर बड़ी संख्या में ऐसे जोड़े खोजें जिन्हें छोटे अभाज्य (smooth numbers) में तोड़ा जा सके। इस प्रक्रिया को “छानना” (sieving) कहा जाता है और इसमें सबसे अधिक समय लगता है।
मैट्रिक्स जनरेशन और रिडक्शन : एकत्रित संबंधों के आधार पर एक विशाल विरल मैट्रिक्स (Sparse matrix) उत्पन्न करें, और रैखिक बीजगणित विधियों (जैसे ब्लॉक लैंज़ोस विधि) का उपयोग करके समाधान खोजें।
वर्गमूल की गणना : अंत में, बीजगणितीय संख्या क्षेत्र पर वर्गमूल की गणना करें और $ N $ के गुणनखंड (अभाज्य गुणनखंड) प्राप्त करें।

GNFS की जटिलता का मूल्यांकन एसिम्प्टोटिक रूप से $ O(\exp((\sqrt[3]{\frac{64}{9}} + o(1)) (\log N)^{\frac{1}{3}} (\log \log N)^{\frac{2}{3}})) $ के रूप में किया जाता है। इसे “उप-घातीय” (Sub-exponential) समय जटिलता कहा जाता है। यद्यपि यह घातीय समय (Exponential time) से तेज़ है, यह बहुपद समय (Polynomial time) से बहुत धीमा है।

वास्तव में, 2020 में, शोधकर्ताओं की एक अंतरराष्ट्रीय टीम ने GNFS का उपयोग करके RSA-250 (एक 829-बिट, 250-अंकीय समग्र संख्या) का सफलतापूर्वक गुणनखंडन किया। इस गणना में दुनिया भर के कंप्यूटिंग संसाधनों का उपयोग करते हुए लगभग 2700 CPU कोर-वर्ष का खगोलीय गणना समय लगा। हालाँकि, जब बात 2048 बिट्स की आती है, तो यह कहा जाता है कि आवश्यक गणना ब्रह्मांड के जीवनकाल के खरबों गुना तक बढ़ जाएगी, जिससे वर्तमान सुपरकंप्यूटरों को कितना भी समानांतर चलाया जाए, शास्त्रीय तरीकों से यथार्थवादी समय के भीतर इसे क्रैक करना असंभव हो जाता है।

क्वांटम कंप्यूटर का ट्रम्प कार्ड: शोर का एल्गोरिदम

यहीं पर “शोर का एल्गोरिदम” (Shor’s Algorithm), जिसे 1994 में पीटर शोर द्वारा प्रस्तुत किया गया था, सामने आता है। यह एल्गोरिदम क्रांतिकारी था क्योंकि यह क्वांटम कंप्यूटर पर बहुपद समय ( $ O((\log N)^3) $ ) में अभाज्य गुणनखंडन समस्या को हल कर सकता था। उप-घातीय समय और बहुपद समय के बीच का अंतर निर्णायक है, जिसका अर्थ है कि सिद्धांत रूप में, यदि हम क्वांटम कंप्यूटर का उपयोग करते हैं, तो RSA एन्क्रिप्शन पूरी तरह से नष्ट हो जाएगा।

शोर के एल्गोरिदम का समग्र प्रवाह

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


graph TD
 A[उस संख्या N को इनपुट करें जिसका आप गुणनखंड करना चाहते हैं] --> B[एक यादृच्छिक पूर्णांक a चुनें]
 B --> C{a और N का<br>महतम समापवर्तक (GCD)}
 C -->|1 से बड़ा| D[सौभाग्य से एक अभाज्य गुणनखंड मिला!]
 C -->|1 सह-अभाज्य| E[क्वांटम कंप्यूटर की बारी]
 E --> F[फलन f_x = a^x mod N की<br>अवधि r को क्वांटम फूरियर ट्रांसफॉर्म से खोजें]
 F --> G{अवधि r सम है और<br>a^r/2 ≢ -1 mod N}
 G -->|हाँ| H[महतम समापवर्तक gcd_a^r/2 ± 1, N की गणना करें]
 H --> I((अभाज्य गुणनखंडन सफल!))
 G -->|नहीं| B

सीधे अभाज्य गुणनखंडन समस्या को हल करने के बजाय, शोर का एल्गोरिदम इसे संख्या सिद्धांत प्रमेयों का उपयोग करके “अवधि खोज समस्या” (Period Finding Problem) नामक एक अन्य समस्या में परिवर्तित करता है, और इसे उच्च गति से हल करने के लिए क्वांटम कंप्यूटर की विशेषताओं का उपयोग करता है।

चरण 1: अभाज्य गुणनखंडन से अवधि खोज समस्या में कमी (शास्त्रीय प्रसंस्करण)

एल्गोरिदम का पहला चरण क्लासिकल कंप्यूटर पर किया जाता है। उस संख्या $ N $ के लिए जिसका आप गुणनखंड करना चाहते हैं, एक यादृच्छिक पूर्णांक $ a $ ( $ 1 < a < N $ ) चुनें जो $ N $ (जिसका सबसे बड़ा सामान्य भाजक 1 है) का सह-अभाज्य (coprime) है। यदि, संयोग से, सबसे बड़ा सामान्य भाजक 1 नहीं है, तो उस समय पाया गया सामान्य भाजक $ N $ का एक अभाज्य गुणनखंड है, इसलिए डिक्रिप्शन पूरा हो गया है, लेकिन इसकी संभावना बहुत कम है।

इसके बाद, निम्नलिखित मॉड्यूलर समीकरणों के अनुक्रम पर विचार करें। $ f(x) = a^x \pmod N $

यदि आप इस फ़ंक्शन $ f(x) $ में $ x = 1, 2, 3, \dots $ डालते हैं, तो मान यादृच्छिक लग सकते हैं, लेकिन चूंकि गणना एक सीमित सीमा के भीतर की जाती है, यह हमेशा किसी बिंदु पर अपने मूल मान पर वापस आ जाएगी और उसी अनुक्रम को दोहराएगी। इस पुनरावृत्ति की अवधि को $ r $ कहा जाता है। दूसरे शब्दों में, न्यूनतम धनात्मक पूर्णांक $ r $ खोजना ताकि $ a^r \equiv 1 \pmod N $ हो, यही “अवधि खोज समस्या” है।

यदि यह अवधि $ r $ मिल जाती है, और $ r $ सम है, तो $ a^r - 1 \equiv 0 \pmod N $, और गुणनखंडन सूत्र का उपयोग करके इसे $ (a^{r/2} - 1)(a^{r/2} + 1) \equiv 0 \pmod N $ में बदला जा सकता है। यहाँ से, यूक्लिडियन एल्गोरिथ्म (Euclidean algorithm) का उपयोग करके $ N $ और $ a^{r/2} \pm 1 $ के सबसे बड़े सामान्य भाजक की गणना करके, $ N $ के अभाज्य गुणनखंडों को बहुत अधिक संभावना के साथ प्राप्त किया जा सकता है।

क्लासिक कंप्यूटर के साथ अवधि $ r $ खोजने के लिए, अंततः घातीय चरणों की आवश्यकता होती है और इसे तेज नहीं किया जा सकता है। हालाँकि, क्वांटम कंप्यूटर के साथ, यह अवधि $ r $ तुरंत (बहुपद समय में) पाई जा सकती है।

चरण 2: क्वांटम स्थिति की तैयारी और सुपरपोजिशन

यहीं से क्वांटम कंप्यूटर काम आते हैं। क्वांटम कंप्यूटर “क्यूबिट्स” (Qubits) का उपयोग करते हैं जिनमें एक ही समय में “0” और “1” दोनों की स्थिति हो सकती है। शोर के एल्गोरिदम में, दो रजिस्टर तैयार किए जाते हैं: इनपुट को स्टोर करने के लिए एक रजिस्टर (पहला रजिस्टर) और गणना परिणाम को स्टोर करने के लिए एक रजिस्टर (दूसरा रजिस्टर)।

सबसे पहले, एक क्वांटम गेट ऑपरेशन जिसे हैडमार्ड गेट (Hadamard gate) कहा जाता है, पहले रजिस्टर में सभी क्यूबिट्स पर लागू किया जाता है। यह पहले रजिस्टर को सभी संभावित $ x $ मानों ( $ 0 $ से $ 2^n-1 $ तक, जहाँ $ n $ पर्याप्त रूप से बड़ी संख्या में बिट्स है) के समान सुपरपोजिशन (uniform superposition) स्थिति में लाता है।

दूसरे शब्दों में, अनगिनत इनपुट मान जैसे $ x=0, 1, 2, 3, \dots $ क्वांटम कंप्यूटर के अंदर एक ही समय में समानांतर में मौजूद होते हैं।

चरण 3: क्वांटम मॉड्यूलर एक्सपोनेंशिएशन (Quantum Modular Exponentiation)

इसके बाद, पहले रजिस्टर की सुपरपोजिशन स्थिति को इनपुट के रूप में उपयोग करते हुए, $ f(x) = a^x \pmod N $ की गणना की जाती है और परिणाम दूसरे रजिस्टर में संग्रहीत किया जाता है। चूँकि यह गणना क्वांटम सर्किट पर एकात्मक परिवर्तन (unitary transformation) के रूप में की जाती है, सभी $ x $ के लिए $ f(x) $ की गणना “एक साथ और समानांतर में (क्वांटम समानता)” की जाती है, जबकि सुपरपोजिशन को बनाए रखा जाता है।

इस बिंदु पर संपूर्ण क्वांटम प्रणाली का स्थान राज्य के एक विशाल सुपरपोजिशन में है: $ |x, a^x \bmod N\rangle $

हालाँकि, यदि हम केवल यहाँ दूसरे रजिस्टर को मापते (निरीक्षण करते) हैं, तो केवल एक यादृच्छिक $ a^x \bmod N $ मान संभाव्य रूप से चुना जाएगा, और पहले रजिस्टर का $ x $ भी इसके संयोजन में निर्धारित किया जाएगा। यह शास्त्रीय कंप्यूटर पर एक बार गणना करने के समान है, और अवधि $ r $ नहीं पाई जा सकती है।

क्वांटम यांत्रिकी के नियमों के तहत, सुपरपोज़्ड अवस्था के अंदर सीधे देखना संभव नहीं है। तो हम पूरी “अवधि” के बारे में वैश्विक जानकारी कैसे निकाल सकते हैं?

चरण 4: क्वांटम फूरियर ट्रांसफॉर्म (QFT: Quantum Fourier Transform)

इस दीवार को तोड़ने वाले शोर के एल्गोरिदम का वास्तविक मूल्य पहले रजिस्टर में क्वांटम फूरियर ट्रांसफॉर्म (QFT) का अनुप्रयोग है।

मापने से पहले, फलन $ f(x) $ की तरंग प्रकृति का विश्लेषण करें। मान लीजिए कि हम दूसरे रजिस्टर का निरीक्षण करते हैं। मान लीजिए कि एक निश्चित मान $ y $ प्राप्त होता है। तब, पहले रजिस्टर की स्थिति “सभी $ x $ के सुपरपोजिशन में ढह जाती है जैसे कि $ a^x \pmod N = y $ “। इस $ x $ के मान $ x_0, x_0 + r, x_0 + 2r, x_0 + 3r, \dots $ होंगे, जो अवधि $ r $ (एक प्रकार का कंघी जैसा संभाव्यता आयाम वितरण) के अंतराल पर अलग-अलग व्यवस्थित होते हैं।

इस अवस्था में क्वांटम फूरियर ट्रांसफॉर्म (QFT) लागू करें। जिस तरह एक क्लासिकल असतत (discrete) फूरियर ट्रांसफॉर्म समय-डोमेन सिग्नल को आवृत्ति डोमेन में परिवर्तित करता है, QFT क्वांटम अवस्थाओं के संभाव्यता आयामों में हस्तक्षेप (interference) का कारण बनता है।

जब QFT लागू किया जाता है, क्वांटम हस्तक्षेप प्रभाव के कारण, गलत उत्तरों की संभावनाएं जो अवधि $ r $ (चरण से बाहर) के साथ प्रतिध्वनित नहीं होती हैं, एक-दूसरे को रद्द कर देती हैं और शून्य (विनाशकारी हस्तक्षेप) तक पहुंच जाती हैं, और केवल अवधि $ r $ के बारे में जानकारी वाले सही उत्तर की संभावना बढ़ जाती है (रचनात्मक हस्तक्षेप)।

चरण 5: मापन और निरंतर अंश विस्तार (शास्त्रीय पोस्ट-प्रोसेसिंग)

QFT को लागू करने के बाद पहले रजिस्टर को मापने से एक पूर्णांक $ c $ प्राप्त करने की बहुत अधिक संभावना होती है जो $ c \approx \frac{j \cdot 2^n}{r} $ के करीब है (जहाँ $ j $ एक अज्ञात पूर्णांक है और $ 2^n $ रजिस्टर का आकार है)।

यह माप परिणाम $ c $ एक क्लासिकल कंप्यूटर पर लौटाया जाता है, और भिन्न $ \frac{c}{2^n} \approx \frac{j}{r} $ बनाया जाता है। फिर, गणितीय विधि “निरंतर अंश विस्तार” (Continued fraction expansion) का उपयोग करके अनुमानित मूल्य की गणना करके, हर (denominator) में अवधि $ r $ को शानदार ढंग से सामने लाया जा सकता है।

एक बार $ r $ ज्ञात हो जाने के बाद, हम चरण 1 के सूत्र का उपयोग करके $ N $ के अभाज्य गुणनखंडों की गणना कर सकते हैं, और RSA एन्क्रिप्शन पूरी तरह से डिक्रिप्ट हो जाएगा।

वर्तमान क्वांटम कंप्यूटरों (NISQ) की क्षमताएं और चुनौतियाँ

सैद्धांतिक रूप से, शोर का एल्गोरिदम सही है, लेकिन अगर पूछा जाए, “क्या कल RSA एन्क्रिप्शन टूट जाएगा?” तो उत्तर स्पष्ट रूप से “नहीं” है। इसका कारण वर्तमान क्वांटम कंप्यूटर हार्डवेयर तकनीक की सीमाएं हैं।

NISQ (Noisy Intermediate-Scale Quantum) युग

हम वर्तमान में “NISQ” नामक युग में हैं। NISQ उपकरणों में दसियों से सैकड़ों भौतिक क्यूबिट्स होते हैं, लेकिन शोर (noise) के प्रति बेहद संवेदनशील होते हैं।

क्यूबिट्स बाहरी वातावरण जैसे गर्मी और विद्युत चुम्बकीय तरंगों के प्रभाव के प्रति संवेदनशील होते हैं, और “डिकोहेरेंस” (क्वांटम उलझाव का नुकसान) और गेट ऑपरेशन के दौरान “गेट त्रुटियां” अक्सर होती हैं, जिससे क्वांटम स्थिति नष्ट हो जाती है। जब शोर के एल्गोरिदम जैसे बहुत गहरे (बड़ी संख्या में गणना चरणों के साथ) क्वांटम सर्किट को निष्पादित करने का प्रयास किया जाता है, तो गणना के दौरान त्रुटियां जमा हो जाती हैं, और अंतिम आउटपुट पूर्ण शोर बन जाता है जिसका कोई अर्थ नहीं होता है।

भौतिक क्यूबिट्स और तार्किक क्यूबिट्स

इस त्रुटि समस्या को हल करने के लिए “क्वांटम त्रुटि सुधार” (Quantum Error Correction) आवश्यक है। त्रुटि सुधार कोड का उपयोग शास्त्रीय कंप्यूटरों में भी किया जाता है, लेकिन “क्वांटम नो-क्लोनिंग प्रमेय” के कारण, जो क्वांटम अवस्थाओं की नकल को रोकता है, क्वांटम त्रुटि सुधार बहुत जटिल है।

क्वांटम त्रुटि सुधार में, “सतह कोड” (Surface Code) जैसी तकनीकों का उपयोग बड़ी संख्या में शोर वाले “भौतिक क्यूबिट्स” को संयोजित करने के लिए किया जाता है ताकि त्रुटियों के बिना एक आदर्श “तार्किक क्यूबिट” (Logical qubit) बनाया जा सके।

वर्तमान त्रुटि दरों को देखते हुए, यह अनुमान लगाया गया है कि एक तार्किक क्यूबिट बनाने के लिए लगभग 1,000 से 10,000 भौतिक क्यूबिट्स की आवश्यकता होगी। इसे “त्रुटि सुधार ओवरहेड” कहा जाता है।

RSA-2048 को नष्ट करने के लिए किन संसाधनों की आवश्यकता है?

तो RSA-2048 को क्रैक करने के लिए शोर के एल्गोरिदम को चलाने के लिए वास्तव में कितने संसाधनों की आवश्यकता है?

क्रेग गिडनी (Google) और मार्टिन एकेरा द्वारा 2021 के एक पेपर में ग्राउंडब्रेकिंग संसाधन अनुमान के अनुसार, अनुकूलित शोर के एल्गोरिदम का उपयोग करके और सतह कोड का उपयोग करके त्रुटि सुधार करने के लिए निम्नलिखित संसाधनों की आवश्यकता होगी:

तार्किक क्यूबिट्स की संख्या : लगभग 4,096
भौतिक क्यूबिट्स की संख्या : लगभग 20 मिलियन (त्रुटि दर $10^{-3}$ मानकर)
गणना का समय : लगभग 8 घंटे (लाखों से अरबों भौतिक गेट संचालन की आवश्यकता है)

इसकी तुलना में, वर्तमान क्वांटम हार्डवेयर की क्या स्थिति है? सुपरकंडक्टिंग क्वांटम प्रोसेसर “कोंडोर”, जिसकी घोषणा 2023 के अंत में IBM द्वारा की गई थी, में 1,121 क्यूबिट्स हैं। इसके अलावा, तार्किक क्यूबिट्स के निर्माण पर ग्राउंडब्रेकिंग शोध (जैसे हार्वर्ड यूनिवर्सिटी और QuEra द्वारा तटस्थ परमाणु क्वांटम कंप्यूटर का उपयोग करके 48 तार्किक क्यूबिट्स का निर्माण) भी सामने आया है, लेकिन हम अभी तक उस स्तर पर नहीं हैं जहाँ “बिना शोर के सही गणना” लंबी अवधि के लिए लगातार निष्पादित की जा सके।

हजारों भौतिक क्यूबिट्स से 20 मिलियन व्यावहारिक भौतिक क्यूबिट्स (जो परस्पर जुड़े हुए हैं, क्रायोजेनिक तापमान पर स्थिर रूप से काम करते हैं, और अति-उच्च गति पर नियंत्रण संकेतों को संसाधित कर सकते हैं) तक स्केल करने के लिए, इंजीनियरिंग में भारी बाधाएं (वायरिंग की समस्याएं, शीतलन क्षमता की सीमाएं, और नियंत्रण इलेक्ट्रॉनिक्स का विस्तार) मौजूद हैं। कई विशेषज्ञों का अनुमान है कि “दोष-सहिष्णु (Fault-tolerant) क्वांटम कंप्यूटर (FTQC)” को साकार करने में कम से कम 10 से 30 वर्ष या उससे अधिक का समय लगेगा जो RSA-2048 को डिक्रिप्ट कर सकता है।

“Store Now, Decrypt Later” का बढ़ता खतरा और PQC की शुरुआत

यह सोचना जल्दबाजी होगी कि “हम सुरक्षित हैं क्योंकि इसमें अभी 10 से अधिक साल लगेंगे।” वर्तमान में, ऐसा डेटा है जिसे राष्ट्रीय रहस्य, चिकित्सा डेटा और दीर्घकालिक बुनियादी ढांचे के डिजाइन जैसे दशकों तक गुप्त रखा जाना चाहिए।

यहाँ जो चिंता का विषय है वह “अभी स्टोर करें, बाद में डिक्रिप्ट करें” (Store Now, Decrypt Later) नामक हमला विधि है। दुर्भावनापूर्ण राष्ट्र और संगठन वर्तमान RSA या ECC (एलिप्टिक कर्व क्रिप्टोग्राफी) के साथ एन्क्रिप्ट किए गए सभी संचार डेटा को इंटरसेप्ट करते हैं और इसे स्टोरेज में सहेजते हैं। फिर, 10 या 20 साल बाद, जिस क्षण एक शक्तिशाली क्वांटम कंप्यूटर पूरा हो जाता है, वे शोर के एल्गोरिदम का उपयोग करके सभी पिछले डेटा को डिक्रिप्ट करते हैं और रहस्यों को उजागर करते हैं।

इस समय अंतराल के खतरे का मुकाबला करने के लिए, NIST (राष्ट्रीय मानक और प्रौद्योगिकी संस्थान) के नेतृत्व में, “पोस्ट-क्वांटम क्रिप्टोग्राफी” (PQC: Post-Quantum Cryptography) के मानकीकरण की प्रक्रिया तेज गति से आगे बढ़ रही है।

PQC एक नया एन्क्रिप्शन एल्गोरिदम है जो गणितीय समस्याओं पर आधारित है जिन्हें क्वांटम कंप्यूटर का उपयोग करके हल करना मुश्किल है (यानी, शोर का एल्गोरिदम लागू नहीं किया जा सकता है)। मुख्य दृष्टिकोण इस प्रकार हैं:

लैटिस-आधारित क्रिप्टोग्राफी (Lattice-based cryptography) : LWE (Learning with Errors) समस्या पर आधारित है। NIST के मानकीकरण में मुख्यधारा (Kyber, Dilithium, आदि)।
कोड-आधारित क्रिप्टोग्राफी (Code-based cryptography) : त्रुटि-सुधार कोड को डिकोड करने की कठिनाई पर निर्भर करता है।
बहुभिन्नरूपी बहुपद क्रिप्टोग्राफी (Multivariate cryptography) : कई चरों के एक साथ द्विघात समीकरणों को हल करने की कठिनाई पर निर्भर करता है।
हैश-आधारित हस्ताक्षर (Hash-based signatures) : डिजिटल हस्ताक्षर जो पूरी तरह से हैश फ़ंक्शंस की सुरक्षा पर निर्भर करते हैं।

Google Chrome और Apple के iMessage जैसे प्रमुख सॉफ़्टवेयर और प्लेटफ़ॉर्म ने पहले ही PQC का कार्यान्वयन परीक्षण और हाइब्रिड कार्यान्वयन शुरू कर दिया है।

निष्कर्ष

क्वांटम कंप्यूटर विज्ञान कथा की काल्पनिक दुनिया से वास्तविक इंजीनियरिंग चुनौतियों की ओर बढ़ रहे हैं। शोर का एल्गोरिदम मानवता की एक महान बौद्धिक उपलब्धि है जो गणित और क्वांटम यांत्रिकी को जोड़ती है, लेकिन साथ ही, इसमें हमारे डिजिटल समाज की नींव को हिला देने वाली “विनाशकारी शक्ति” है।

RSA एन्क्रिप्शन कल अचानक अनुपयोगी नहीं हो जाएगा। हालाँकि, क्वांटम प्रौद्योगिकी के विकास और “अभी स्टोर करें, बाद में डिक्रिप्ट करें” के जोखिमों को देखते हुए, PQC में संक्रमण, क्रिप्टोग्राफी के इतिहास में एक बड़े पैमाने पर प्रवासन (migration), पहले ही शुरू हो चुका है। हम वर्तमान में सूचना सुरक्षा में एक प्रतिमान बदलाव (paradigm shift) में सबसे आगे गवाह हैं।

【संपूर्ण विश्लेषण】C++ में लागू करके सबसे शक्तिशाली क्रिप्टोग्राफी क्रैकिंग एल्गोरिदम "GNFS" को समझना

Sat, 05 Sep 2026 13:04:59 +0900

【संपूर्ण विश्लेषण】C++ में लागू करके सबसे शक्तिशाली क्रिप्टोग्राफी क्रैकिंग एल्गोरिदम “GNFS” को समझना

आधुनिक इंटरनेट का आधार “RSA क्रिप्टोग्राफी” है। इसकी मजबूती इस गणितीय विश्वास पर निर्भर करती है कि “वर्तमान कंप्यूटरों के लिए एक विशाल भाज्य संख्या (composite number) का अभाज्य गुणनखंडन (prime factorization) करना लगभग असंभव है”।

हालाँकि, मानवता ने कभी हार नहीं मानी है। वर्तमान में, क्लासिकल कंप्यूटरों (सामान्य कंप्यूटर, न कि क्वांटम कंप्यूटर) पर विशाल अभाज्य गुणनखंडन करने के लिए ** मानवता का सबसे शक्तिशाली और उन्नत एल्गोरिदम ** मौजूद है। वह है ** “सामान्य संख्या क्षेत्र चलनी (GNFS: General Number Field Sieve)” ** ।

इस लेख में, हम इस GNFS के अत्याधुनिक संगणना लॉजिक को C++ (Boost लाइब्रेरी के मल्टीपल-प्रिसीजन इंटीजर boost::multiprecision का उपयोग करके) में सख्ती से मॉडल किए गए कार्यान्वयन कोड को पूरी तरह से प्रकाशित करेंगे, और इसके पीछे “बीजीय संख्या सिद्धांत (Algebraic Number Theory)” की गहराइयों को विस्तार से समझाएंगे।

कृपया स्रोत कोड के साथ गणित के रहस्य और कंप्यूटर विज्ञान की उस शक्ति का आनंद लें जो इसे मात देती है।

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 आदि द्वारा
// Special-q Lattice Sieving (विशेष-q जालक चलनी) का उपयोग करना डिफ़ॉल्ट मानक है।
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*...) में मैप करती है,
 // और कैश दक्षता को अधिकतम करने वाली चलनी (sieve) चलाती है।

 // डेमो के लिए एक डमी रिलेशन जोड़ा गया
 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;
 // विरल मैट्रिक्स (sparse matrix) और वेक्टर के गुणन की पुनरावृत्ति करके,
 // 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's method आदि)
 // विशाल बीजीय क्षेत्र O_K का तत्व gamma ज्ञात करना, और समरूपता (homomorphism) phi द्वारा वास्तविक दुनिया में मैप करना
 // Y = phi(gamma) mod N
 cpp_int Y = 1;

 // आदर्श वर्ग समूह (Ideal Class Group) और इकाई समूह (Unit Group) की बाधाओं (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;

 // RSA-270 आदि, विशाल भाज्य संख्या N जिसका गुणनखंडन करना है
 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 ही नहीं, बल्कि लगभग सभी आधुनिक विशाल अभाज्य गुणनखंडन एल्गोरिदम का लक्ष्य एक ऐसा गैर-तुच्छ (non-trivial) युग्म $(X, Y)$ खोजना है जो निम्नलिखित सर्वांगसमता (congruence) को संतुष्ट करता हो:

$$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$ से छोटा एक सार्व भाजक (common divisor)” मौजूद होगा। यहाँ, यदि हम यूक्लिड के एल्गोरिदम का उपयोग करके ** $\gcd(X-Y, N)$ ** की गणना करते हैं, तो $N$ का अभाज्य गुणनखंड आसानी से मिल जाएगा।

हालाँकि, इस $X$ और $Y$ को खोजना रेगिस्तान में सुई खोजने जैसा है। इसलिए, GNFS “वास्तविक पूर्णांकों की दुनिया” और “बहुपदों की बीजीय दुनिया” नामक ** 2 दुनियाएँ ** बनाने और संगणना को वितरित करने का एक प्रतिभाशाली दृष्टिकोण अपनाता है।

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$ नामक “रिंग होमोमोर्फिज्म (Ring 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 के जालक में मैप करता है,
 // और कैश दक्षता को अधिकतम करने वाली चलनी (sieve) चलाता है।
 // ...
 }
};

एक बार जब दोनों दुनियाएँ तैयार हो जाती हैं, तो अगला कदम उन दोनों दुनियाओं में “स्मूथ संख्याएँ (केवल छोटी अभाज्य संख्याओं से बनी संख्याएँ)” खोजना है। पूर्णांक युग्मों $(a, b)$ की अनगिनत संख्या उत्पन्न की जाती है, और निम्नलिखित दो मानों की गणना की जाती है:

** परिमेय पक्ष का मान ** : $a - bm$
** बीजीय पक्ष का नॉर्म ** : $b^d f(a/b)$

GNFS का लक्ष्य ऐसे ** “युग्मों (Relation: संबंध) को करोड़ों की संख्या में इकट्ठा करना है जहाँ परिमेय और बीजीय दोनों मानों को पूरी तरह से केवल छोटे अभाज्य कारकों में विभाजित किया जा सकता है” ** ।

शुरुआती GNFS में, एक “सरल रेखा चलनी (Line Sieve)” का उपयोग किया जाता था जो $(a, b)$ को $xy$-तल पर रखता था और उन्हें एक सिरे से अभाज्य संख्याओं द्वारा क्रमिक रूप से विभाजित करता था। हालाँकि, इसमें मेमोरी के कई स्थानों तक पहुँचने के कारण लगातार कैश मिस होने और बहुत धीमा होने की कमजोरी थी।

इसलिए, वर्तमान अत्याधुनिक कोड में ** “विशेष $q$ जालक चलनी (Special-q Lattice Sieve)” ** नामक तकनीक का उपयोग किया जाता है। एक उपयुक्त रूप से बड़ी अभाज्य संख्या $q$ तय की जाती है, और केवल उन $(a, b)$ युग्मों की गणना की जाती है जहाँ “बीजीय पक्ष का मान निश्चित रूप से $q$ द्वारा विभाज्य है”। इस शर्त को पूरा करने वाले $(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$ “केवल 1 बार” आती है। हमारा लक्ष्य “सभी अभाज्य संख्याओं के घातांकों को सम (2 का गुणज) बनाना” है, इसलिए जो अभाज्य संख्या केवल 1 बार आती है उसे कभी सम नहीं किया जा सकता। इसलिए, उस अभाज्य संख्या वाले रिलेशन को तुरंत “कचरा” मानकर हटा (पर्ज) दिया जाता है। चूँकि यह एक श्रृंखला प्रतिक्रिया में होता है, करोड़ों पंक्तियों वाला डेटा तेज़ी से कम हो जाता है।
** Clique merging (क्लीक मर्जिंग) ** इसके अलावा, एक विशिष्ट अभाज्य संख्या साझा करने वाले रिलेशन को एक साथ गुणा करके (जोड़कर), पंक्तियों की संख्या कम हो जाती है, जबकि एक विरल (sparse) मैट्रिक्स को सघन स्थिति में संकुचित किया जाता है (ग्राफ सिद्धांत में क्लीक सर्च के समान एक विधि का उपयोग किया जाता है)।

इस अनुकूलन के साथ, विशाल विरल मैट्रिक्स को गणना योग्य आकार में नाटकीय रूप से संकुचित किया जाता है।

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) {
 // विरल मैट्रिक्स (sparse matrix) और वेक्टर के गुणन की पुनरावृत्ति करके,
 // M * x = 0 mod 2 को संतुष्ट करने वाले कई हल वेक्टर (कर्नेल) खोजना।
 }
};

यह पहेली का मूल है। हम एकत्र किए गए रिलेशन को गुणा करते हैं ताकि ** “ऐसे संयोजन को खोज सकें जहाँ सभी अभाज्य कारकों के घातांक सम हो जाते हैं” ** ।

गणितीय रूप से, यह एक विशाल मैट्रिक्स $M$ जिसमें प्रत्येक अभाज्य संख्या के घातांक की “सम/विषम (यानी 0 या 1)” स्थिति होती है, और यह दर्शाने वाला एक वेक्टर $x$ कि किन रिलेशन का उपयोग किया जाए, का उपयोग करके: ** $M \cdot x \equiv 0 \pmod 2$ ** संतुष्ट करने वाले हल वेक्टर $x$ (शून्यस्थान / कर्नेल) को खोजने के अलावा और कुछ नहीं है।

हमें लाखों पंक्तियों × लाखों स्तंभों वाले मैट्रिक्स के युगपत समीकरणों को हल करना होगा। सामान्य गाऊसी उन्मूलन (Gaussian elimination) से गणना की जटिलता $O(N^3)$ हो जाएगी, और गणना ब्रह्मांड के अंत तक भी समाप्त नहीं होगी।

इसलिए, अत्याधुनिक कार्यान्वयन ** “Block Wiedemann (ब्लॉक विडमैन) विधि” ** को अपनाता है। यह क्रिलोव सबस्पेस विधि का एक प्रकार है जो इस तथ्य का लाभ उठाता है कि मैट्रिक्स $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$ प्राप्त किया है जो, जब गुणा किया जाता है, तो सभी अभाज्य कारकों की सम घात में परिणत होता है”। यह हमें परिमेय और बीजीय दोनों दुनियाओं में “वर्ग (Squares)” बनाने की अनुमति देता है।

चूँकि परिमेय पक्ष केवल पूर्णांक गुणन है, इसलिए वर्गमूल $V$ की गणना करना आसान है।

$$V^2 = \prod_{S} (a - bm)$$

** लेकिन असली चुनौती “बीजीय पक्ष” पर है। ** बीजीय क्षेत्र $\mathbb{Z}[\alpha]$ की दुनिया में, अभाज्य गुणनखंडन की विशिष्टता (unique factorization) लागू नहीं होती है, इसलिए हमने आदर्शों (ideals) का उपयोग करके गणना की है। मैट्रिक्स गणना केवल यह गारंटी देती है कि यह “आदर्श का वर्ग” है, और ** यह गारंटी नहीं देता है कि यह “तत्व का वर्ग ($\gamma^2$)” बन जाता है ** ।

यहाँ बीजीय संख्या सिद्धांत में एक दुर्जेय दीवार है, जिसे “आदर्श वर्ग समूह (Ideal Class Group) की बाधा” और “इकाई समूह (Unit Group) की बाधा” कहा जाता है। GNFS में, इस दीवार को तोड़ने के लिए ** “द्विघाती वर्णों (Quadratic Characters)” ** नामक जादू का उपयोग किया जाता है। Phase 4 के मैट्रिक्स में, दर्जनों विशेष अभाज्य आदर्शों के लिए द्विघाती अवशेषों (लेजेंड्रे प्रतीक) की पंक्तियों को चुपके से पहले से जोड़ दिया जाता है। इस वजह से, पाया गया सेट $S$ भारी संभावना के साथ बाधाओं को बायपास करेगा, और सुरक्षित रूप से “सच्चे तत्व का वर्ग $\gamma^2$” बनाएगा।

$\gamma$ (बीजीय वर्गमूल) ज्ञात करने का कार्य Montgomery विधि जैसे अत्यंत जटिल एल्गोरिदम का उपयोग करके किया जाता है।

और अंततः, बीजीय पक्ष के वर्गमूल $\gamma$ को रिंग होमोमोर्फिज्म $\phi$ द्वारा वास्तविक दुनिया में ले जाया जाता है ($x$ के लिए $m$ प्रतिस्थापित करके), जिससे हमें $Y$ मिलता है। यदि हम परिमेय पक्ष के $V$ को वैसे ही $X$ के रूप में रखते हैं, तो वह पूर्ण समीकरण जो हम खोज रहे थे, अंततः पूरा हो जाता है।

$$X^2 \equiv Y^2 \pmod N$$

अब बस $\gcd(X-Y, N)$ की गणना करनी है। 0.001 सेकंड का प्रसंस्करण चलता है, और जैसे ही गैर-तुच्छ कारक स्क्रीन पर प्रिंट होते हैं, अभेद्य मानी जाने वाली RSA क्रिप्टोग्राफी पूरी तरह से ढह जाती है।

निष्कर्ष

GNFS सिर्फ एक प्रोग्रामिंग तकनीक नहीं है। यह मानव बुद्धि का क्रिस्टलीकरण है जिसने “शुद्ध गणित की गहराइयों” जैसे अमूर्त बीजगणित (abstract algebra), रिंग थ्योरी (ring theory), और आदर्श वर्ग समूहों (ideal class groups) को “चरम इंजीनियरिंग” जैसे सुपरकंप्यूटर वितरित आर्किटेक्चर और कैश अनुकूलन के साथ जीत लिया है।

हम जिन चैट और क्रेडिट कार्ड की जानकारी को लापरवाही से भेजते हैं, वे ऐसे खगोलीय गणितीय बचावों द्वारा संरक्षित हैं।

हमें उम्मीद है कि इस C++ फ्रेमवर्क के माध्यम से, आप अत्याधुनिक क्रिप्टोग्राफी क्रैकिंग एल्गोरिदम के पीछे “गणित और कंप्यूटर के रोमांस” को महसूस करेंगे।

इंटरनेट एन्क्रिप्शन को तोड़ने वाला मानवता का सबसे शक्तिशाली गणित "General Number Field Sieve (GNFS)" क्या है?

Sat, 05 Sep 2026 02:09:08 +0900

इंटरनेट एन्क्रिप्शन को तोड़ने वाला मानवता का सबसे शक्तिशाली गणित “General Number Field Sieve (GNFS)” क्या है?

जिस इंटरनेट का हम हर दिन उपयोग करते हैं। LINE संदेश, YouTube, Amazon पर खरीदारी आदि, सभी संचार “एन्क्रिप्शन” द्वारा सुरक्षित हैं। वर्तमान में, दुनिया में सबसे अधिक उपयोग किया जाने वाला एन्क्रिप्शन “RSA एन्क्रिप्शन” है।

RSA एन्क्रिप्शन की रक्षा की कुंजी बहुत सरल है। यह इस गणितीय गुण का उपयोग करता है कि ** “विशाल संख्याओं का अभाज्य गुणनखंडन कंप्यूटर द्वारा भी हल नहीं किया जा सकता है” ** । उदाहरण के लिए, “15” के लिए हम तुरंत जान जाते हैं कि यह “3 × 5” है, लेकिन जैसे ही यह “270 अंकों की संख्या” बन जाता है, भले ही हम दुनिया के सभी सुपर कंप्यूटरों को मिला दें, इसे हल करने में करोड़ों साल लगेंगे।

हालाँकि, गणितज्ञ भी चुप नहीं रहे। इस अभेद्य एन्क्रिप्शन को तोड़ने के लिए, मानवता ने एक लगभग जादुई एल्गोरिदम (गणना प्रक्रिया) बनाया है जिसे ** “General Number Field Sieve (GNFS)” ** कहा जाता है।

इस लेख में, किसी भी तकनीकी शब्द का उपयोग किए बिना, केवल ** मिडिल स्कूल के गणित (अभाज्य गुणनखंडन, बीजगणितीय व्यंजक, महत्तम समापवर्तक) ** के ज्ञान के साथ, हम चरण-दर-चरण समझाएंगे कि “मानवता का यह सबसे शक्तिशाली एल्गोरिदम” एन्क्रिप्शन को कैसे तोड़ता है!

अध्याय 1: डिकोडिंग का लक्ष्य एक “8वीं कक्षा का सूत्र” है

विशाल अभाज्य गुणनखंडन का सामना करने के लिए सबसे बड़ी विशेष चाल। यह 8वीं कक्षा में सीखा गया सूत्र है:

** $X^2 - Y^2 = (X + Y)(X - Y)$ **

आप सोच सकते हैं: “सच में, क्या ऐसा बुनियादी सूत्र एन्क्रिप्शन को तोड़ सकता है?"। हालाँकि, यह वह मास्टर की है जो सब कुछ खोल देती है।

एन्क्रिप्शन को तोड़ने का सबसे बड़ा लक्ष्य, एक विशाल संख्या $N$ के लिए, ** “ऐसे संख्याएँ ($X$ और $Y$) खोजना है जहाँ $X^2$ और $Y^2$ को $N$ से विभाजित करने पर शेषफल समान हो” ** ।

“समान शेषफल” एन्क्रिप्शन को क्यों तोड़ता है?

मान लीजिए कि दो संख्याओं, $X^2$ और $Y^2$, का “$N$ से विभाजित करने पर समान शेषफल” है। समान शेषफल होने का मतलब है कि एक नियम है जहाँ ** घटाव “$X^2 - Y^2$” हमेशा $N$ से पूरी तरह से विभाज्य होगा ($N$ का गुणज होगा) ** ।

यहाँ, मान लें कि एन्क्रिप्शन में प्रयुक्त विशाल संख्या $N$ दो गुप्त अभाज्य संख्याओं ($p$ और $q$) के गुणन से बनी है ($N = p \times q$)।

$X^2 - Y^2$ का गुणनखंडन करने पर, हमें ** $(X - Y)(X + Y)$ ** मिलता है। इसका $N$ का गुणज होने का अर्थ है कि इस गुणन में कहीं न कहीं गुप्त अभाज्य संख्याएँ $p$ और $q$ छिपी हैं।

यहाँ, एक चमत्कार होता है। गणितीय रूप से ** 50% (आधा) ** संभावना है कि दो अभाज्य संख्याएँ $p$ और $q$ अलग-अलग कमरों में चली जाएँगी: ** “$p$ $(X - Y)$ के कमरे में जाता है” और “$q$ $(X + Y)$ के कमरे में जाता है” ** ।

केवल अभाज्य संख्या $p$ के $(X - Y)$ कक्ष में प्रवेश करने के साथ, आइए $(X - Y)$ और $N$ के ** “महत्तम समापवर्तक (सबसे बड़ा उभयनिष्ठ भाग)” ** की गणना करें।

$(X - Y)$ की सामग्री = $p \times$ कोई संख्या
$N$ की सामग्री = $p \times q$ एकमात्र सामान्य भाग ** “$p$” ** है!

दूसरे शब्दों में, जैसे ही महत्तम समापवर्तक की गणना की जाती है, छिपी हुई अभाज्य संख्या $p$ लीक हो जाती है और एन्क्रिप्शन पूरी तरह से डिकोड हो जाता है। (*“यूक्लिडियन एल्गोरिदम” का उपयोग करके स्मार्टफोन पर भी महत्तम समापवर्तक की तुरंत गणना की जा सकती है)।

** 【छोटा कॉलम: वर्ग क्यों? घन या दोगुना काम क्यों नहीं करता?】 **

“$2X - 2Y$” के साथ, यह $2(X - Y)$ हो जाता है और केवल एक कमरा होता है, इसलिए आप अभाज्यों को अलग नहीं कर सकते। “$X^3 - Y^3$” के साथ, कमरे का आकार असंतुलित हो जाता है और गणना अनावश्यक रूप से भारी हो जाती है। अभाज्यों को दो में अलग करने के लिए, “वर्ग” जो पूरी तरह से दो कमरों में विभाजित होता है, सबसे अधिक लागत प्रभावी है।

अध्याय 2: X और Y कैसे खोजें? “अभाज्य संख्या कार्ड संग्रह पहेली”

लक्ष्य समझ में आ गया है। हालाँकि, भले ही हम आँख बंद करके “$X^2$ और $Y^2$ जिनके समान शेषफल हैं” की खोज करें, ब्रह्मांड का अंत उन्हें खोजने से पहले आ जाएगा। इसलिए, गणितज्ञ एक शानदार विचार लेकर आए जिसे ** “अभाज्य संख्या कार्ड संग्रह पहेली” ** कहा जाता है।

चरण 1: छलनी से केवल सोने की धूल (smooth numbers) एकत्र करें

सबसे पहले, एक उपयुक्त संख्या $Z$ तैयार करें, इसे वर्ग करें और इसे $N$ से विभाजित करके शेषफल $W$ की गणना करें। ($Z^2 = W$ की शेषफल दुनिया)

प्राप्त शेषफल $W$ का अभाज्य गुणनखंडन करें। यहाँ, केवल जब ** “2, 3, 5, 7, आदि जैसे छोटे अभाज्यों से बना $W$” ** दिखाई देता है, तो उस समीकरण को “विजेता कार्ड” के रूप में रखें, और यदि बड़े अभाज्य मिश्रित हों तो इसे फेंक दें। यह नदी में छलनी से बड़े पत्थरों को फेंकने और केवल सोने की धूल इकट्ठा करने जैसा है।

चरण 2: सबको “सम” बनाने की पहेली

उदाहरण के लिए, मान लीजिए कि निम्नलिखित 3 सोने की धूल वाले कार्ड एकत्र किए गए हैं।

कार्ड A: $Z_1^2 = 2^3 \times 3^1$
कार्ड B: $Z_2^2 = 2^1 \times 5^1$
कार्ड C: $Z_3^2 = 3^1 \times 5^1$

आइए उन सभी को गुणा करें। दाईं ओर $(2^3 \times 3^1) \times (2^1 \times 5^1) \times (3^1 \times 5^1)$ हो जाता है, और सब कुछ एक साथ व्यवस्थित करने पर, यह ** “$2^4 \times 3^2 \times 5^2$” ** बन जाता है।

आश्चर्य की बात है, अभाज्य संख्याओं की संख्या “4, 2, 2” हो गई, ** सभी सम संख्याएँ हैं ** ! सभी सम होने का अर्थ है कि यदि आप कुल राशि को आधा कर देते हैं, तो यह “किसी चीज़ का वर्ग” होगा। दूसरे शब्दों में, $(2^2 \times 3^1 \times 5^1)^2 = (60)^2$।

बाईं ओर $(Z_1 \times Z_2 \times Z_3)^2$ है, तो अंततः, ** $X = (Z_1 \times Z_2 \times Z_3)$ ** ** $Y = 60$ ** “$X^2 = Y^2$” की बहुप्रतीक्षित जोड़ी पूरी हो गई है!

कंप्यूटर के लिए, यह गणना करने की पहेली कि अभाज्य संख्याओं की संख्या “सम है या विषम (0 या 1)” कुछ ऐसा है जिसमें वे बहुत अच्छे हैं, इसलिए इस पद्धति के साथ $X$ और $Y$ उच्च गति पर पाए जा सकते हैं।

अध्याय 3: निराशा की दीवार

अब किसी भी एन्क्रिप्शन को तोड़ा जा सकता है! …या हमने ऐसा सोचा, लेकिन एक बड़ी समस्या उत्पन्न होती है। यदि एन्क्रिप्शन संख्या $N$ “100 अंक” तक है, तो यह विधि (जिसे Quadratic Sieve कहा जाता है) इसे हल कर सकती है, लेकिन जब $N$ “200 या 300 अंक” बन जाता है, तो गणना के मध्य में आने वाला $W$ बहुत बड़ा हो जाता है।

जब संख्याएँ बहुत बड़ी हो जाती हैं, तो “केवल छोटी अभाज्य संख्याओं (सोने की धूल) से बनी संख्याएँ” आना बंद हो जाती हैं। रेगिस्तान में कॉन्टैक्ट लेंस खोजना अधिक कठिन हो जाता है, और पहेली को सुलझाने के लिए आवश्यक कार्ड बिल्कुल भी एकत्र नहीं होंगे।

यहाँ, अंततः, मानवता का अंतिम हथियार, ** “General Number Field Sieve (GNFS)” ** प्रकट होता है।

अध्याय 4: मानवता का “दो दुनिया” बनाने का सबसे शक्तिशाली विचार

GNFS का शानदार विचार है: ** “संख्याएँ विशाल हो जाती हैं क्योंकि हम केवल वास्तविक दुनिया में गणना करते हैं। तो, चलिए गणना के भार को दो भागों में विभाजित करने के लिए बहुपदों (अक्षर सूत्रों) का उपयोग करके एक ‘पर्दे के पीछे की दुनिया’ बनाते हैं।” **

अक्षर सूत्रों का जादू

GNFS आधार संख्या $m$ का उपयोग करके विशाल संख्या $N$ को अक्षर व्यंजक में परिवर्तित करता है। उदाहरण के लिए यदि $N=100$, $m=4$ के साथ, तो यह $100 = 4^3 + 2(4^2) + 4$ है। अक्षर $x$ का उपयोग करके इसे सूत्र (पर्दे के पीछे की दुनिया) में बदलते हैं: ** $f(x) = x^3 + 2x^2 + x$ ** ।

इस सूत्र की दिलचस्प बात यह है कि इसमें यह गुण है: ** “यदि आप $x$ के स्थान पर $m$ (उपरोक्त उदाहरण में 4) रखते हैं, तो आप हमेशा वास्तविक संख्या $N$ पर वापस लौट सकते हैं” ** ।

एक साथ 2 दुनियाओं में सोने की धूल की तलाश

GNFS यादृच्छिक पूर्णांक जोड़े $(a, b)$ बनाता है और एक साथ निम्नलिखित दो गणनाएं करता है:

** वास्तविक दुनिया ** : $a - b \times m$
** अक्षरों की दुनिया ** : बहुपद नियमों द्वारा गणना की गई $a - b \times x$ का मूल्य

समस्या को दो दुनियाओं में विभाजित करके, संभाली गई संख्याओं का आकार काफी कम (हल्का) हो जाता है। यह एक विशाल चट्टान को आसान से संभालने वाले पत्थरों में विभाजित करने जैसा है।

फिर, आप केवल उन चमत्कारी जोड़ियों $(a, b)$ को अलग करने और इकट्ठा करने के लिए छलनी का उपयोग करते हैं जहाँ ** “वास्तविक दुनिया और अक्षरों की दुनिया दोनों में, वे ‘केवल छोटी अभाज्य संख्याओं (सोने की धूल) से बने’ हैं” ** । यही “Number Field Sieve” नाम का मूल है।

वह क्षण जब एन्क्रिप्शन अंततः टूट जाता है

एक बार दोनों दुनियाओं से करोड़ों “गोल्ड डस्ट कार्ड” एकत्र हो जाने के बाद, सुपरकंप्यूटर “वह संयोजन खोजने के लिए जहां अभाज्य संख्याओं की संख्या सभी सम हों” के लिए विशाल मैट्रिक्स गणना का उपयोग करते हैं, ठीक वैसे ही जैसे हमने अध्याय 2 में किया था।

एक बार संयोजन मिल जाने के बाद:

वास्तविक दुनिया में वर्ग संख्या को ** $X^2$ ** होने दें
अक्षरों की दुनिया में बनाए गए वर्ग सूत्र को ** $Y(x)^2$ ** होने दें

अंततः, अक्षर सूत्र $Y(x)$ में $x$ के स्थान पर $m$ को रखें, वास्तविक दुनिया में वापस कूदें और उनसे जुड़ें। फिर, गणितीय जादू की तरह, वह स्थिति जहाँ ** “$X^2$ और $Y^2$ का शेषफल समान है” ** पूरी तरह से सिद्ध हो जाती है!

बाकी, अध्याय 1 की तरह, केवल $X - Y$ और $N$ के महत्तम समापवर्तक की गणना करना है, और अभेद्य RSA एन्क्रिप्शन ढह जाएगा, जिससे गुप्त अभाज्य संख्याएँ सामने आ जाएंगी।

निष्कर्ष: गणित कभी समाप्त नहीं होता

आप सोच रहे होंगे: “बढ़िया, GNFS के साथ किसी भी एन्क्रिप्शन को तोड़ा जा सकता है!"। हालाँकि, RSA एन्क्रिप्शन ने भी हार नहीं मानी है। आज इंटरनेट पर जो उपयोग किया जाता है वह एक राक्षसी विशाल संख्या है जिसे “RSA-2048 (लगभग 617 अंक)” कहा जाता है।

GNFS मानवता का सबसे शक्तिशाली एल्गोरिदम है, लेकिन 270 अंकों (RSA-270) को हल करने के लिए भी कहा जाता है कि दुनिया भर के कंप्यूटरों को जोड़ने पर भी हजारों या दसियों हजार साल लगेंगे। अभी के लिए, हमारे LINE और बैंक डेटा सुरक्षित हैं।

लेकिन क्या होगा यदि ** “किसी भी विशाल संख्या के लिए $X$ और $Y$ को तुरंत खोजने का जादू” ** प्रकट हो जाए? वास्तव में, इसके सबसे करीब ** “क्वांटम कंप्यूटर (Shor का एल्गोरिदम)” ** है जो वर्तमान में विकास में है। क्वांटम यांत्रिकी की तरंग प्रकृति का उपयोग करते हुए, यह गणितीय रूप से सिद्ध हो गया है कि थकाऊ कार्ड संग्रह पहेली को दरकिनार करना और एक ही बार में उत्तर तक पहुंचना संभव है।

एन्क्रिप्शन बनाने वालों (रक्षा) और इसे तोड़ने के लिए एल्गोरिदम बनाने वालों (हमला) के बीच बुद्धि की एक अंतहीन लड़ाई। यह जानकर कि मिडिल स्कूल में सीखा गया “अभाज्य गुणनखंडन” और “अक्षर व्यंजक” वास्तव में वे हथियार हैं जो वैश्विक सुरक्षा की अग्रिम पंक्ति में लड़ रहे हैं, क्या गणित की कक्षाएं थोड़ी अधिक दिलचस्प नहीं लगती हैं?

जो भविष्य के सबसे मजबूत एल्गोरिदम की खोज करेगा, वह आप ही हो सकते हैं जो इस लेख को पढ़ रहे हैं!

(※यह लेख छात्रों के लिए कोड-ब्रेकिंग के गणितीय आकर्षण का एक वैचारिक रूपांतरण है। वास्तविक GNFS की गणना उच्च विश्वविद्यालय गणित, जैसे बीजीय संख्या क्षेत्रों के आदर्श वर्ग समूहों और समरूपता का उपयोग करके सख्ती से की जाती है)

केप्लर अनुमान की सरल व्याख्या

Mon, 21 Jul 2025 22:53:03 +0900

केप्लर अनुमान की सरल व्याख्या! तरबूज को सबसे घनी तरह से पैक करने का तरीका

नमस्ते, मैं kenji हूँ!

आज मैं “केप्लर अनुमान” नामक गणित के एक ऐसे विषय को समझाने की कोशिश करूँगा, जिसका नाम थोड़ा कठिन लगता है, लेकिन मैं इसे यथासंभव आसान बनाऊँगा।

पहली नज़र में, यह बहुत ही अजीब विषय लग सकता है, लेकिन यह एक बहुत ही व्यावहारिक समस्या भी है: “हम एक डिब्बे में तरबूजों को सबसे घनी तरह से कैसे पैक कर सकते हैं?"। इसका संबंध सुविधा स्टोर के रेफ्रिजरेटर और सामान को स्टैक करने के तरीके से भी है।

और गणित की दुनिया में, इसके पीछे एक बहुत ही रोमांटिक कहानी है कि यह 400 से अधिक वर्षों तक सिद्ध नहीं हो सका ।

चलिए शुरू करते हैं!

केप्लर आखिर कौन था?

सबसे पहले, “केप्लर अनुमान” में “केप्लर” कौन है?

यह एक जर्मन खगोलशास्त्री और गणितज्ञ जोहान्स केप्लर (Johannes Kepler) का नाम है।

यह आदमी बहुत ही अद्भुत था। उदाहरण के लिए, वह वही थे जिन्होंने खोजा कि ग्रहों की कक्षाएँ अण्डाकार हैं। आज यह सामान्य ज्ञान है, लेकिन उस समय (लगभग 1600 में), यह एक ऐसा युग था जब हेलियोसेंट्रिज़्म (सूर्य-केंद्रित प्रणाली) पर भी मुश्किल से विश्वास किया जाता था।

गैलीलियो = अवलोकन के प्रतिभा
केप्लर = गणितीय सूत्रों के साथ ब्रह्मांड को समझाने वाले प्रतिभा
न्यूटन = वह सुपर जीनियस जिसने उस सिद्धांत को भौतिकी के नियमों में संक्षेप में प्रस्तुत किया

इस स्थिति के साथ, केप्लर “गणितीय सूत्रों के साथ ब्रह्मांड के बारे में बात करने” में अग्रणी थे।

और, एक समय, उसने यह कहा:

केप्लर अनुमान क्या है?

संक्षेप में, “केप्लर अनुमान” इस प्रकार है।

समान आकार के गोले (तरबूज या संतरे) को एक डिब्बे में पैक करते समय, कौन सी व्यवस्था सबसे घनी पैकिंग की अनुमति देती है?

यही समस्या है।

और 1600 के दशक में केप्लर ने जो अनुमान लगाया वह था:

क्या उन्हें त्रिकोण की तरह स्टैक करना सबसे कुशल नहीं होगा, जैसे ग्रीनग्रोसर संतरे प्रदर्शित करते हैं?

गणितीय भाषा में, इसे “सबसे घना पैकिंग समस्या (Sphere Packing)” कहा जाता है, जो अंतरिक्ष में गोले को सबसे घनी तरह से पैक करने का तरीका खोजने की समस्या है।

केप्लर ने अनुमान लगाया कि “फेस-सेंटर्ड क्यूबिक स्ट्रक्चर (FCC)” (तरबूजों को त्रिकोणीय पैटर्न में स्टैक करने की तरह) नामक व्यवस्था सबसे कुशल होगी।

सभी ने सोचा, “हाँ, यह निश्चित रूप से सही लगता है…”, लेकिन गणितीय रूप से यह साबित करना कि “यह बिल्कुल सबसे अच्छा है!” बेहद मुश्किल था।

साबित होने में 400 साल लगे!?!

तो, वास्तव में इसे कब सिद्ध किया गया…?

आश्चर्यजनक रूप से, 1998 से 2005 के आसपास । यानी, लगभग 400 वर्षों तक कोई भी इसे साबित नहीं कर सका । यह बहुत पागलपन है।

इसके अलावा, इसे साबित करने वाले एक अमेरिकी गणितज्ञ थे जिनका नाम थॉमस हेल्स (Thomas Hales) था।

उन्होंने महसूस किया कि यह केवल मैन्युअल गणना से असंभव होगा, इसलिए उन्होंने साबित करने के लिए कंप्यूटर का उपयोग किया । हालाँकि, समस्या यह उत्पन्न हुई कि प्रमाण इतना जटिल था कि मनुष्य इसे ठीक से नहीं जाँच सकते थे!

इसलिए, गणितीय दुनिया में भी एक बड़ी बहस छिड़ गई: “तो, क्या हम वास्तव में कंप्यूटर द्वारा किए गए प्रमाण पर भरोसा कर सकते हैं?"।

अंततः, वह प्रमाण (औपचारिक रूप से “औपचारिक प्रमाण” कहा जाता है) जिसमें कहा गया था कि “मैंने कंप्यूटर सहित इसकी कड़ाई से पुष्टि की है!” 2014 में पूरा हुआ।

यानी, यह साबित होने में 400 से अधिक वर्ष लग गए कि केप्लर का अंतर्ज्ञान सही था । क्या रोमांस है।

वास्तविक जीवन में भी बहुत उपयोग किया जाता है

आप सोच सकते हैं कि “गोले को कैसे व्यवस्थित किया जाए” केवल गणित के दीवानों के लिए एक विषय है, लेकिन वास्तव में यह बहुत व्यावहारिक है।

सुविधा स्टोर के रेफ्रिजरेटर में कुशलता से पेय पैक करने के लिए
कैन को ट्रांसपोर्ट पैलेट पर स्टैक करते समय
यह संचार (डिजिटल सिग्नल कम्प्रेशन, आदि) में भी लागू होता है
3D प्रिंटर और क्रिस्टल संरचनाओं के डिजाइन में उपयोग किया जाता है

आदि, यह वास्तव में एक सिद्धांत है जिसका उपयोग हमारे जीवन के पीछे बड़े पैमाने पर किया जाता है।

निष्कर्ष: मानव अंतर्ज्ञान अद्भुत है

तो, चलिए संक्षेप में बताते हैं।

केप्लर अनुमान = गोलों को सबसे घनी तरह से कैसे पैक किया जाए, इसकी समस्या
श्रीमान केप्लर = गणितज्ञ और खगोलशास्त्री जिन्होंने ग्रहों की कक्षाओं की खोज की
1600 के दशक में अनुमान लगाया गया! लेकिन 2000 के दशक में साबित हुआ!
वास्तविक जीवन में भी बहुत लागू!

और सबसे दिलचस्प बात यह है कि: “जिस तरह से ग्रीनग्रोसर अपने अंतर्ज्ञान से फलों को स्टैक करते थे, वह गणितीय रूप से भी सबसे मजबूत था” ।

दूसरे शब्दों में, मानव अंतर्ज्ञान अद्भुत है । और यह तथ्य कि इसे साबित करने में 400 साल लग सकते हैं , वास्तव में एक रोमांटिक कहानी है, है ना?

यदि आप रुचि रखते हैं, तो कृपया “थॉमस हेल्स”, “औपचारिक प्रमाण”, “Sphere Packing” आदि खोजें। गहराई में जाना बहुत मजेदार है।

फिर मिलेंगे!

[PR]

今すぐ購入

अभाज्य संख्याएँ उत्पन्न करने के लिए C कोड

Sat, 24 Aug 2024 09:38:10 +0900

नीचे एक सरल C कोड दिया गया है जो एक निर्दिष्ट सीमा के भीतर अभाज्य संख्याएँ (prime numbers) उत्पन्न करता है। इस उदाहरण में, हम 1 से n तक की अभाज्य संख्याओं को सूचीबद्ध करते हैं।

 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


#include <stdio.h>
#include <stdbool.h>

bool isPrime(int num) {
 if (num <= 1) return false;
 if (num <= 3) return true;
 if (num % 2 == 0 || num % 3 == 0) return false;

 for (int i = 5; i * i <= num; i += 6) {
 if (num % i == 0 || num % (i + 2) == 0) return false;
 }
 return true;
}

void printPrimes(int n) {
 printf("2 ");
 for (int i = 3; i <= n; i += 2) {
 if (isPrime(i)) {
 printf("%d ", i);
 }
 }
 printf("\n");
}

int main() {
 int n;
 printf("अभाज्य संख्याएँ उत्पन्न करने के लिए सीमा का अधिकतम मान दर्ज करें: ");
 scanf("%d", &n);
 printf("1 से %d तक की अभाज्य संख्याएँ निम्नलिखित हैं:\n", n);
 printPrimes(n);
 return 0;
}

यह कोड इस प्रकार काम करता है:

isPrime फ़ंक्शन: यह निर्धारित करता है कि दी गई संख्या अभाज्य है या नहीं। दक्षता के लिए, यह पहले जाँचता है कि क्या यह 2 और 3 से विभाज्य है, और फिर 6 के गुणकों में जाँच के साथ आगे बढ़ता है।
printPrimes फ़ंक्शन: निर्दिष्ट सीमा के भीतर अभाज्य संख्याएँ आउटपुट करता है। 2 सबसे पहले आउटपुट होता है, और फिर केवल विषम संख्याओं की जाँच की जाती है।
main फ़ंक्शन: उपयोगकर्ता से सीमा का अधिकतम मान दर्ज करने के लिए कहता है, और उस सीमा के भीतर अभाज्य संख्याएँ आउटपुट करता है।

यदि आप इस कोड को संकलित और चलाते हैं, तो निर्दिष्ट सीमा के भीतर अभाज्य संख्याएँ प्रदर्शित होंगी।

Mathematica का परिचय

Thu, 25 Jul 2024 01:36:19 +0900

Mathematica का परिचय

समीकरण हल करना

1

Solve[x^2 - 3 x + 2 == 0, x]

आउटपुट

1

{{x -> 1}, {x -> 2}}

पूर्णांक सीमा में समीकरण का हल ढूँढना

1

Solve[x^2 - 3 x + 2 == 0 && 0 <= x <= 2, x, Integers]

आउटपुट

1

{{x -> 1}, {x -> 2}}

युगपत समीकरण हल करना

1

Solve[{x + y == 3, x - y == 1}, {x, y}]

आउटपुट

1

{{x -> 2, y -> 1}}

असमानताएं हल करना

1

Reduce[x^2 - 3 x + 2 > 0, x]

आउटपुट

1

x < 1 || x > 2

अवकलन करना

1

D[x^2, x]

आउटपुट

1

2 x

समाकलन करना

1

Integrate[x^2, x]

आउटपुट

1

x^3/3

सीमा ज्ञात करना

1

Limit[1/x, x -> 0]

आउटपुट

1

Infinity

श्रृंखला ज्ञात करना

1

Sum[1/n^2, {n, 1, Infinity}]

आउटपुट

1

π^2/6

मैट्रिक्स बनाना

1

m = {{1, 2}, {3, 4}}

मैट्रिक्स का गुणनफल ज्ञात करना

1

m . m

आउटपुट

1

{{7, 10}, {15, 22}}

व्युत्क्रम मैट्रिक्स ज्ञात करना

1

Inverse[m]

आउटपुट

1

{{-2, 1}, {1.5, -0.5}}

आइगेनवैल्यू और आइगेनवेक्टर ज्ञात करना

1

Eigensystem[m]

आउटपुट

1

{{5, 0}, {{1, 1}, {1, -1}}}

सदिशों का बिंदु गुणनफल ज्ञात करना

1

{1, 2} . {3, 4}

आउटपुट

1

11

सदिशों का क्रॉस गुणनफल ज्ञात करना

1

Cross[{1, 2, 3}, {4, 5, 6}]

आउटपुट

1

{-3, 6, -3}

सदिश का परिमाण ज्ञात करना

1

Norm[{1, 2, 3}]

आउटपुट

1

√14

सदिशों का कोण ज्ञात करना

1

ArcCos[{1, 2} . {3, 4}/(Norm[{1, 2}] Norm[{3, 4}])]

आउटपुट

1

ArcCos[11/(√5 √25)]

सदिश का प्रक्षेपण ज्ञात करना

1

{1, 2} . {3, 4}/Norm[{3, 4}] {3, 4}/Norm[{3, 4}]

आउटपुट

1

{11/5, 22/5}

सदिश का घूर्णन ज्ञात करना

1

RotationMatrix[π/2].{1, 0}

आउटपुट

1

{0, 1}

सदिश का स्थानांतरण ज्ञात करना

1

TranslationTransform[{1, 2}][{3, 4}]

आउटपुट

1

{4, 6}

सदिश की स्केलिंग ज्ञात करना

1

ScalingTransform[{2, 3}][{1, 1}]

आउटपुट

1

{2, 3}

सदिश का परावर्तन ज्ञात करना

1

ReflectionTransform[{1, 1}][{1, 1}]

आउटपुट

1

{0, 0}

यादृच्छिक संख्याएँ उत्पन्न करना

1

RandomReal[]

आउटपुट

1

0.123456

यादृच्छिक संख्याएँ उत्पन्न करना (पूर्णांक)

1

RandomInteger[]

आउटपुट

1

123456

यादृच्छिक संख्याएँ उत्पन्न करना (सीमा निर्दिष्ट)

1

RandomReal[{1, 10}]

आउटपुट

1

5.6789

यादृच्छिक संख्याएँ उत्पन्न करना (पूर्णांक, सीमा निर्दिष्ट)

1

RandomInteger[{1, 10}]

आउटपुट

1

5

यादृच्छिक संख्याएँ उत्पन्न करना (वितरण निर्दिष्ट)

1

RandomVariate[NormalDistribution[0, 1]]

आउटपुट

1

0.123456

यादृच्छिक संख्याएँ उत्पन्न करना (वितरण, मात्रा निर्दिष्ट)

1

RandomVariate[NormalDistribution[0, 1], 10]

आउटपुट

1

{0.123456, 0.234567, ..., 0.987654}

यादृच्छिक संख्याएँ उत्पन्न करना (वितरण, मात्रा, बीज निर्दिष्ट)

1
2


SeedRandom[12345]
RandomVariate[NormalDistribution[0, 1], 10]

आउटपुट

1

{0.123456, 0.234567, ..., 0.987654}

सरणी के तत्वों पर फ़ंक्शन लागू करना

1
2
3


Map[Sqrt, {1, 4, 9}]
Sqrt /@ {1, 4, 9}
Map[#^(1/2)&, {1, 4, 9}]

आउटपुट

1

{1, 2, 3}

लैम्ब्डा एक्सप्रेशन का उपयोग करके फ़ंक्शन परिभाषित करना

1
2


f = Function[x, x^2]
f[3]

आउटपुट

1

9

फ़ंक्शन रचना

1
2
3
4


f = Function[x, x^2]
g = Function[x, x + 1]
h = Function[x, f[g[x]]]
h[3]

आउटपुट

1

16

पिछली गणना के परिणाम का संदर्भ देना

1

% + 1

आउटपुट

1

17

शुद्ध फ़ंक्शन

1

(#+3)&[5]

आउटपुट

1

8

सरणी निष्कर्षण

1
2


Select[{1, 2, 3, 4, 5}, EvenQ]
Select[{1, 2, 3, 4, 5}, Mod[#,2]==0&]

आउटपुट

1

{2, 4}

गणित की अनसुलझी समस्याएँ

Sat, 02 Mar 2024 22:57:36 +0900

गणित की अनसुलझी समस्याएँ

यहाँ गणित की अनसुलझी समस्याओं के बारे में बताया गया है। हालाँकि समस्याएँ सरल हैं, लेकिन ऐसी कई समस्याएँ हैं जो अभी तक सिद्ध नहीं हुई हैं।

क्या पूर्ण संख्याएँ अनंत हैं?

पूर्ण संख्या वह प्राकृतिक संख्या है जिसके धनात्मक विभाजकों (स्वयं को छोड़कर) का योग स्वयं उस संख्या के बराबर होता है। उदाहरण के लिए,

6 के विभाजक 1, 2, 3 हैं, और चूँकि 1+2+3=6 है, यह एक पूर्ण संख्या है।
28 के विभाजक 1, 2, 4, 7, 14 हैं, और चूँकि 1+2+4+7+14=28 है, यह एक पूर्ण संख्या है।

वर्तमान में केवल 51 पूर्ण संख्याएँ खोजी गई हैं, और यह अनुमान है कि वे अनंत हैं, लेकिन यह अभी तक सिद्ध नहीं हुआ है।

गोल्डबैक अनुमान

गोल्डबैक अनुमान यह है कि 2 से बड़ी प्रत्येक सम संख्या को दो अभाज्य संख्याओं के योग के रूप में व्यक्त किया जा सकता है। (यहाँ अभाज्य संख्या वह प्राकृतिक संख्या है जिसके 1 और स्वयं के अलावा कोई विभाजक नहीं होते हैं।)

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

4=2+2
6=3+3
8=3+5
10=3+7=5+5

समस्या अपने आप में बहुत सरल है, लेकिन इसे अभी तक सिद्ध नहीं किया गया है।

रीमैन परिकल्पना

रीमैन परिकल्पना यह अनुमान है कि रीमैन ज़ीटा फ़ंक्शन के शून्य केवल ऋणात्मक सम संख्याएँ और वे सम्मिश्र संख्याएँ हैं जिनका वास्तविक भाग 1/2 है।

रीमैन ज़ीटा फ़ंक्शन $\zeta$ को इस प्रकार परिभाषित किया गया है, जहाँ $s$ एक सम्मिश्र संख्या है और $n$ एक प्राकृतिक संख्या है:

$$\zeta(s):=\sum _{n=1}^{\infty }{\frac {1}{n^{s}}}=1+{\frac {1}{2^{s}}}+{\frac {1}{3^{s}}}+{\frac {1}{4^{s}}}+\cdots$$

इरेटोस्थनीज की छलनी का उपयोग करके 1000 से कम अभाज्य संख्याओं को सूचीबद्ध करने की विधि

Sun, 09 Apr 2023 12:54:24 +0900

इरेटोस्थनीज की छलनी क्या है?

इरेटोस्थनीज की छलनी एक एल्गोरिथ्म है जो किसी दी गई संख्या से छोटे सभी अभाज्य संख्याओं (prime numbers) को सूचीबद्ध करता है। यह एल्गोरिथ्म सरल है और इसे निम्नलिखित चरणों में लागू किया जा सकता है:

N तत्वों वाली एक बूलियन ऐरे बनाएँ और सभी तत्वों को true से इनिशियलाइज़ करें।
ऐरे के 0वें और 1ले तत्व को false सेट करें (क्योंकि 0 और 1 अभाज्य नहीं हैं)।
यदि ऐरे का दूसरा तत्व true है, तो 2 को अभाज्य के रूप में आउटपुट करें।
ऐरे में $2^2$ और उससे अधिक 2 के गुणजों (multiples) वाले तत्वों को false सेट करें ※
यदि ऐरे का तीसरा तत्व true है, तो 3 को अभाज्य के रूप में आउटपुट करें।
ऐरे में $3^2$ और उससे अधिक 3 के गुणजों वाले तत्वों को false सेट करें।
चौथे, 5वें, …, Nवें तत्वों के लिए यही प्रक्रिया दोहराएँ।

※ हम वर्गों (squares) से ऊपर के तत्वों को false सेट करते हैं क्योंकि वर्ग से छोटी संख्याओं पर पहले ही प्रक्रिया हो चुकी होती है।

Rust में कार्यान्वयन

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


fn main() {
 let n = 1000;
 let mut is_prime = vec![true; n+1];
 is_prime[0] = false;
 is_prime[1] = false;
 for i in 2..=n {
 if is_prime[i] {
 println!("{}", i);
 let mut j = i * i;
 while j <= n {
 is_prime[j] = false;
 j += i;
 }
 }
 }
}

थोड़ा अनुकूलित संस्करण

निम्नलिखित बिंदुओं को ध्यान में रखते हुए, हम थोड़ा तेज़ कार्यान्वयन बना सकते हैं:

ऐरे को true के बजाय false से इनिशियलाइज़ करें (यह तेज़ है)।
चूँकि 2 के गुणज अभाज्य नहीं होते हैं, इसलिए 2 के गुणजों को false सेट करने की प्रक्रिया को छोड़ दें।
n तक लूप करने की आवश्यकता नहीं है; n के वर्गमूल तक अभाज्य संख्याओं को सूचीबद्ध करना, n से छोटे या उसके बराबर सभी अभाज्यों को खोजने के लिए पर्याप्त है।

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


fn main() {
 let n = 1000;
 let mut is_prime = vec![false; n+1];
 is_prime[2] = true;
 for i in (3..=n).step_by(2) {
 is_prime[i] = true;
 }
 for i in 3..=((n as f64).sqrt() as usize) {
 if is_prime[i] {
 let mut j = i * i;
 while j <= n {
 is_prime[j] = false;
 j += i * 2;
 }
 }
 }
 for i in (2..=n).filter(|&x| is_prime[x]) {
 println!("{}", i);
 }
}

संदर्भ

इरेटोस्थनीज की छलनी

Python (matplotlib.pyplot) का उपयोग करके ग्राफ़ कैसे बनाएं

Sun, 09 Apr 2023 01:02:19 +0900

आपको क्या चाहिए

Google खाता

चरण

https://colab.research.google.com/ पर जाएं
“फ़ाइल” -> “नई नोटबुक” चुनें
नीचे दिए गए कोड को पेस्ट करें और चलाएं

1
2
3
4
5
6
7


import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 2*np.pi, 500)
plt.plot(x, np.sin(x), label="sin curve")
plt.plot(x, np.cos(x), label="cos curve")
plt.legend() # लीजेंड दिखाएं
plt.show()

निष्पादन परिणाम

संदर्भ

matplotlib.pyplot — Matplotlib 3.5.3 documentation

मुझे गणित और कंप्यूटर क्यों पसंद हैं

Fri, 23 Sep 2022 01:56:52 +0900

मैंने सोचा कि मुझे गणित और कंप्यूटर क्यों पसंद हैं

सभी के लिए समान

यह हमेशा एक ही इनपुट के लिए एक ही आउटपुट देता है, चाहे व्यक्ति, स्थिति या स्थान कुछ भी हो।

स्पष्ट नियम

नियम स्पष्ट रूप से परिभाषित हैं और कोई बेतुकापन या अन्याय नहीं है।

व्युत्पन्न उत्तर और सिद्धांत हमेशा के लिए सही हैं

एक बार निकाले गए उत्तर के बाद में फिर से लिखे जाने की चिंता करने की आवश्यकता नहीं है।

एक मध्यम कठिनाई है

हमेशा अनसुलझी समस्याएं होती हैं, और आप किसी भी समय समस्या समाधान को चुनौती दे सकते हैं।

गणित के महान लोग

Thu, 22 Sep 2022 23:06:37 +0900

फेरमा (P, de Fermat, 1601-1665)

17वीं सदी के फ्रांस के महान गणितज्ञ। विश्लेषणात्मक ज्यामिति, प्रायिकता सिद्धांत और कलन की नींव रखी। वे संख्या सिद्धांत के जनक भी हैं।

डायोफैंटस (Diophantus, 207 के आसपास-291 के आसपास)

यूनानी गणितज्ञ। प्रतीकों का परिचय देने और परिमेय संख्या समाधान के अध्ययन के लिए प्रसिद्ध। उनकी पुस्तक ‘अरिथमेटिका’ प्रमुख कृति है। समीकरणों के परिमेय समाधान खोजने के क्षेत्र को डायोफैंटाइन विश्लेषण कहा जाता है।

यूलर (L. Euler, 1707-1783)

स्विट्जरलैंड में जन्मे गणित के राजा। गणित के हर संभव क्षेत्र में उपलब्धियां हासिल कीं। 700 से अधिक शोध पत्र और 45 पुस्तकें छोड़ीं।

लीजेंड्रे (A. M. Legendre, 1752-1833)

फ्रांसीसी गणितज्ञ। संख्या सिद्धांत, अण्डाकार अभिन्न, और गुरुत्वाकर्षण समस्याओं में कई उपलब्धियां छोड़ीं। “संख्या सिद्धांत” शब्द उनकी मुख्य पुस्तक ‘संख्या सिद्धांत’ से आया है।

कुमेर (E. E. Kummer, 1810-1893)

जर्मन गणितज्ञ। फेरमा के अंतिम प्रमेय में साइक्लोटॉमिक क्षेत्र के संख्या सिद्धांत को लागू करके बड़ी सफलता प्राप्त की।

डेसकार्टेस (R. Descartes, 1596-1650)

फ्रांस के मौलिक दार्शनिक। प्रमुख रचनाओं में ‘प्रणाली पर प्रवचन’, ‘ज्यामिति’ और ‘ब्रह्मांड विज्ञान’ शामिल हैं।

पास्कल (B. Pascal, 1623-1662)

प्रायिकता सिद्धांत और तरल पदार्थों के अध्ययन के लिए जाने जाने वाले फ्रांसीसी दार्शनिक। बाद में जैनसेनिस्टों में शामिल हो गए और धार्मिक गतिविधियों में संलग्न हुए। ‘पेंसेज़’ उस समय की उनकी रचना है।

बाचेट (C. G. Bachet, 1581-1638)

फ्रांसीसी रईस जिन्होंने एक शौक के रूप में संख्या पहेली का अध्ययन किया। डायोफैंटस की ‘अरिथमेटिका’ का लैटिन अनुवाद प्रकाशित किया, और उसमें अपने शोध को टिप्पणियों के रूप में शामिल किया।

वालिस (J. Wallis, 1616-1703)

अंग्रेजी गणितज्ञ। अपनी प्रमुख कृति ‘अनंत का अंकगणित’ में गणितीय रूप में सीमा की अवधारणा दी और कलन की नींव रखने में योगदान दिया।

ब्राउनकर (W. Brouncker, 1620-1684)

आयरिश रईस। रॉयल सोसाइटी (ब्रिटिश अकादमी) के पहले अध्यक्ष। वे गणित के प्रति उत्साही थे और वालिस जैसे लोगों से बातचीत करते थे।

लैग्रेंज (J. L. Lagrange, 1736-1813)

इटली में जन्मे फ्रांसीसी गणितज्ञ। यूलर के उत्तराधिकारी के रूप में बर्लिन अकादमी में गणित विभाग के निदेशक के रूप में कार्य किया। संख्या सिद्धांत और विश्लेषणात्मक यांत्रिकी में प्रमुख उपलब्धियां हासिल कीं।

सीगल (C. L. Siegel, 1896-1981)

जर्मन संख्या सिद्धांतकार। संख्याओं के विश्लेषणात्मक सिद्धांत में कई योगदान दिए।

फाइबोनैचि (L. Fibonacci, 1175 के आसपास-1250 के आसपास)

इतालवी गणितज्ञ। अपनी मुख्य कृति ‘लिबर एबसी’ में इंडो-अरबी अंकों का उपयोग किया और उनके प्रसार के लिए काम किया। साथ ही, ‘बुक ऑफ स्क्वायर्स’ में सर्वांगसम संख्याओं पर चर्चा की।

बेकर (A. Baker, 1939-)

ब्रिटिश संख्या सिद्धांतकार। पारलौकिक संख्या सिद्धांत में उनके योगदान के लिए उन्हें हीसुके हिरोनाका के साथ फील्ड्स मेडल से सम्मानित किया गया था।

पोंकारे (J. Poincare, 1854-1912)

अंतिम सार्वभौमिक गणितज्ञ कहलाने वाले फ्रांसीसी गणितज्ञ। ऑटोमॉर्फिक फ़ंक्शंस, गैर-यूक्लिडियन ज्यामिति, अंतर समीकरण, आकाशीय यांत्रिकी और विद्युत गतिशीलता के साथ-साथ वैज्ञानिक टिप्पणियों सहित उत्कृष्ट रचनाएँ छोड़ीं।

मोर्डेल (L. J. Mordell, 1888-1972)

अमेरिकी मूल के गणितज्ञ। माता-पिता लिथुआनिया के आप्रवासी थे। डायोफैंटाइन समीकरणों के सिद्धांत पर कई पत्र लिखे हैं, लेकिन अण्डाकार घटता के सिद्धांत में मोर्डेल का प्रमेय विशेष रूप से प्रसिद्ध है। वेइल ने इसे सामान्य बीजीय वक्रों के मामले में विस्तारित किया, और यहाँ से अंकगणितीय बीजीय ज्यामिति का विस्फोटक विकास शुरू हुआ।

वेइल (A. Weil, 1906-)

यहूदी मूल के फ्रांसीसी गणितज्ञ। जब वे छोटे थे, तो उनकी फेरमा समस्या में रुचि थी, और उन्होंने संख्या सिद्धांत में इसे लागू करने के उद्देश्य से बीजीय ज्यामिति की मौलिक समीक्षा की, और एक सख्त नींव रखी। वे गणित के इतिहास पर अपने काम के लिए भी जाने जाते हैं।

मेर्सन (M. Mersenne, 1588-1648)

फ्रांसीसी मिनिम आदेश के पुजारी। उन्होंने विभिन्न स्थानों के गणितज्ञों के बीच पत्राचार का समन्वय किया। मेर्सन संख्या भी वास्तव में फेरमा द्वारा सोची गई एक संख्या है।

रोबरवाल (G. P. de Roberval, 1602-1675)

फ्रांसीसी गणितज्ञ। उस समय, वे लगभग एकमात्र व्यक्ति थे जिन्हें एक गणितज्ञ के रूप में प्रोफेसर का पद मिला था, और वे साइक्लोइड के अपने अध्ययन के लिए जाने जाते हैं।

एबेल (N. H. Abel, 1802-1829)

नॉर्वेजियन गणितज्ञ। सामान्य 5-डिग्री समीकरणों की अघुलनशीलता, अण्डाकार कार्य सिद्धांत, और हाबिलियन अभिन्न सिद्धांत जैसी उत्कृष्ट उपलब्धियां हासिल कीं, लेकिन कम उम्र में मृत्यु हो गई।

जैकोबी (K. G. Jacob, 1804-1851)

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

गॉस (C. F. Gauss, 1777-1855)

जर्मनी में जन्मे गणित के राजा। संख्या सिद्धांत, गैर-यूक्लिडियन ज्यामिति, भूगणित, हाइपरजियोमेट्रिक श्रृंखला, सतह सिद्धांत और भू-चुंबकत्व के अध्ययन के लिए जाने जाते हैं। वे एक पूर्णतावादी थे और कहा जाता है कि जब तक काम इतना परिपूर्ण नहीं हो जाता था कि उसका आधार भी न दिखे, तब तक वे परिणाम प्रकाशित नहीं करते थे। प्रमुख कृति ‘अरिथमेटिकल इन्वेस्टिगेशन’ आदि।

लामे (G. Lame, 1795-1870)

फ्रांसीसी गणितज्ञ। लोच के सिद्धांत, गर्मी चालन के सिद्धांत आदि में योगदान दिया।

लिउविल (J. Liouville, 1809-1882)

फ्रांसीसी गणितज्ञ। विभेदक समीकरण, पारलौकिक संख्या सिद्धांत और कार्य सिद्धांत में योगदान दिया।

कॉची (A. L. Cauchy, 1789-1857)

फ्रांसीसी गणितज्ञ। बहुत विपुल थे और सैद्धांतिक भौतिकी और गणित में कई उपलब्धियां हासिल कीं। कहा जाता है कि फ्रांस में उनका गॉस के बराबर सम्मान किया जाता है।

गैलवा (E. Galois, 1811-1832)

फ्रांसीसी गणितज्ञ। एबेल के प्रमेय को स्पष्ट किया कि समूह की अवधारणा को पेश करके 5 डिग्री या उससे अधिक के समीकरणों को आम तौर पर बीजगणितीय रूप से हल नहीं किया जा सकता है। एक द्वंद्वयुद्ध में कम उम्र में मारे गए, लेकिन अब यह ज्ञात है कि इसका कारण एक तुच्छ महिला समस्या थी।

हेंसल (K, Hensel, 1861-1941)

जर्मन गणितज्ञ। क्रोनकर के छात्र। कार्य-सैद्धांतिक तरीकों को लागू करके, उन्होंने संख्या सिद्धांत में पी-एडिक (p-adic) संख्या प्रणाली का सिद्धांत पेश किया।

हेसे (H. Hesse, 1898-1979)

जर्मन गणितज्ञ। हेंसल के छात्र, जिन्होंने p-adic विश्लेषण की नींव और इसके अनुप्रयोगों में योगदान दिया। वर्ग क्षेत्र सिद्धांत का विकास, अण्डाकार वक्रों के एल-फ़ंक्शन का अध्ययन, आदि।

क्रोनकर (L. Kronecker, 1823-1891)

यहूदी मूल के जर्मन गणितज्ञ। अण्डाकार कार्य सिद्धांत, संख्या सिद्धांत, आदि में योगदान दिया। गणित की अंकगणितीय नींव की वकालत करने के लिए जाने जाते हैं, लेकिन उनके अत्यधिक व्यक्तिपरक व्यक्तित्व के कारण, बर्लिन विश्वविद्यालय में उनके सहयोगी वीयरस्ट्रास की अनुचित आलोचना और कैंटर के रोजगार में बाधा ने उनके जीवन पर एक नकारात्मक प्रभाव डाला है।

हिल्बर्ट (D. Hilbert, 1862-1943)

जर्मन गणितज्ञ। अपरिवर्तनीय सिद्धांत, बीजीय संख्या सिद्धांत और गणित की नींव सहित गणित के हर क्षेत्र में एक विशाल पदचिह्न छोड़ा। 1900 में पेरिस में गणितज्ञों की अंतर्राष्ट्रीय कांग्रेस में उनके द्वारा प्रस्तावित 23 समस्याओं का गणित के विकास पर गहरा प्रभाव पड़ा।

रीमैन (B. Riemann, 1826-1866)

जर्मन गणितज्ञ। जटिल कार्य सिद्धांत में रीमैन सतहों की अवधारणा, रीमैन ज्यामिति आदि जैसे गणित की नींव से संबंधित प्रमुख उपलब्धियां हासिल कीं।

फाल्टिंग्स (G. Faltings, 1954-)

जर्मन गणितज्ञ। 1983 में मोर्डेल अनुमान का समाधान किया।

विल्स (A, Wiles, 1953-)

ब्रिटिश मूल के गणितज्ञ। इवासावा के मुख्य अनुमान और बर्च और स्विनर्टन-डायर अनुमान के शोध में प्रमुख योगदान दिया, इस क्षेत्र में वे अग्रणी हैं।

संदर्भ

फ़र्मेट का अंतिम प्रमेय हल हो गया! यूलर से वाइल्स के प्रमाण तक कोदन्शा

गणितज्ञों वाली फिल्में

Mon, 05 Sep 2022 10:41:00 +0900

यहाँ मेरी अनुशंसित 3 फिल्में हैं जिनमें मुख्य पात्र गणितज्ञ हैं।

ए ब्यूटीफुल माइंड

यह एक वास्तविक अमेरिकी प्रतिभाशाली गणितज्ञ के आधे जीवन को दर्शाने वाली फिल्म है। अंत में एक आश्चर्यजनक मोड़ है। रसेल क्रो ने मुख्य भूमिका में बेहतरीन काम किया है।

एनिग्मा

2001 में रिलीज़ हुई फिल्म, जो रॉबर्ट हैरिस के उपन्यास “एनिग्मा” पर आधारित है। विकिपीडिया से

यह जर्मनी द्वारा बनाई गई एनिग्मा एन्क्रिप्शन मशीन को डिक्रिप्ट करने की कहानी है।

द इमिटेशन गेम

यह भी एनिग्मा से जुड़ी एक डिक्रिप्शन कहानी है। मुझे उस समय की दुनिया बहुत पसंद है।

द मैन हू न्यू इन्फिनिटी

कैम्ब्रिज विश्वविद्यालय के गणितज्ञ हार्डी और भारतीय गणितज्ञ रामानुजन के बीच बातचीत को दर्शाने वाली फिल्म। आप इसमें गणित की सुंदरता को महसूस कर सकते हैं।

द थ्योरी ऑफ एवरीथिंग

डॉ. हॉकिंग के जीवन को दर्शाने वाली फिल्म।

पार्टिकल फीवर

[गणितीय सूत्रों से पूर्ण समझ] क्लासिकल में सबसे शक्तिशाली 'GNFS' क्वांटम एल्गोरिदम से क्यों हारता है? अभाज्य गुणनखंडन का पैराडाइम शिफ्ट

Mon, 01 Jan 0001 00:00:00 +0000

आधुनिक इंटरनेट समाज में सूचना सुरक्षा, RSA क्रिप्टोग्राफी जैसी पब्लिक-की क्रिप्टोग्राफी प्रणालियों द्वारा सुरक्षित है। RSA क्रिप्टोग्राफी की सुरक्षा का आधार इस तथ्य पर निर्भर करता है कि “विशाल भाज्य संख्याओं का अभाज्य गुणनखंडन (Prime Factorization) कम्प्यूटेशनल रूप से अत्यंत कठिन है” ।

इस लेख में, हम क्लासिकल कंप्यूटरों के लिए सबसे शक्तिशाली अभाज्य गुणनखंडन एल्गोरिदम “सामान्य संख्या क्षेत्र चलनी” (General Number Field Sieve, GNFS) के गणितीय तंत्र को खोलेंगे, और गणितीय सूत्रों तथा वैचारिक आरेखों (concept diagrams) का उपयोग करके गहराई से यह विश्लेषण करेंगे कि यह पीटर शोर द्वारा खोजे गए “शोर के एल्गोरिदम” (Shor’s Algorithm) से पूरी तरह क्यों हार जाता है, और यह पैराडाइम शिफ्ट कैसे होता है।

1. क्लासिकल कंप्यूटिंग में अभाज्य गुणनखंडन का दृष्टिकोण: फर्मेट की अभाज्य गुणनखंडन विधि से विकास

अभाज्य गुणनखंडन समस्या का अर्थ है, दी गई एक भाज्य संख्या (composite number) $N$ के लिए अभाज्य संख्याओं $p, q$ को खोजना, जिससे $N = p \times q$ हो।

मूल विचार निम्नलिखित सर्वांगसमता (congruence) को संतुष्ट करने वाले गैर-तुच्छ (non-trivial) $x, y$ खोजने पर आ जाता है:

$$ x^2 \equiv y^2 \pmod N $$

इसे रूपांतरित करने पर,

$$ x^2 - y^2 \equiv 0 \pmod N $$ $$ (x - y)(x + y) \equiv 0 \pmod N $$

यहाँ, यदि $x \not\equiv \pm y \pmod N$ हो, तो $\gcd(x-y, N)$ या $\gcd(x+y, N)$ की गणना करके, $N$ का एक गैर-तुच्छ गुणनखंड प्राप्त किया जा सकता है। यह तथ्य GNFS जैसे आधुनिक अभाज्य गुणनखंडन एल्गोरिदम का आधार है।

2. क्लासिकल का सबसे शक्तिशाली एल्गोरिदम: “सामान्य संख्या क्षेत्र चलनी” (GNFS) की गहराई

“GNFS” आज ज्ञात क्लासिकल कंप्यूटरों के लिए सबसे तेज़ अभाज्य गुणनखंडन एल्गोरिदम है। इसकी समय जटिलता (time complexity) उप-घातांकीय (Sub-exponential) समय लेती है।

GNFS की समय जटिलता

जब संख्या $N$ के अंकों की संख्या $b = \log_2 N$ हो, तो GNFS की जटिलता इस प्रकार व्यक्त की जाती है:

$$ O\left( \exp \left( \left(\frac{64}{9} b\right)^{1/3} (\log b)^{2/3} \right) \right) $$

जैसा कि इस सूत्र से देखा जा सकता है, जटिलता बहुपद समय (polynomial time) नहीं है, बल्कि घातांकीय फ़ंक्शन (exponential function) से थोड़ी धीमी “उप-घातांकीय समय” (sub-exponential time) है। फिर भी, यदि अंकों की संख्या बढ़ती है तो गणना का समय खगोलीय रूप से बढ़ जाता है।

GNFS का गणितीय तंत्र

GNFS मुख्य रूप से 4 चरणों से मिलकर बना है:

बहुपद चयन (Polynomial Selection)
छानना (Sieving)
मैट्रिक्स न्यूनीकरण (Matrix Reduction)
वर्गमूल की गणना (Square Root)

2.1. बहुपद चयन और बीजीय संख्या क्षेत्र (Algebraic Number Field)

सबसे पहले, पूर्णांक गुणांकों (integer coefficients) वाले अलघुकरणीय बहुपदों (irreducible polynomials) $f(x)$ और $g(x)$ को चुना जाता है। इन्हें इस प्रकार सेट किया जाता है कि इनका modulo $N$ पर एक सामान्य मूल $m$ हो। अर्थात,

$$ f(m) \equiv 0 \pmod N $$ $$ g(m) \equiv 0 \pmod N $$

आमतौर पर, $g(x)$ को रैखिक बहुपद $g(x) = x - m$ के रूप में चुना जाता है। यदि $f(x)$ के मूल को $\alpha$ मान लिया जाए, तो $\mathbb{Q}(\alpha)$ नामक “संख्या क्षेत्र” (Number Field) बनता है। $\mathbb{Q}(\alpha)$ के वलय (ring) में संचालन और सामान्य पूर्णांक वलय $\mathbb{Z}$ के संचालन की तुलना होमोमोर्फिज़्म (homomorphism) $\phi: \alpha \mapsto m$ के माध्यम से की जाती है।

2.2. छानना (Sieving)

इसके बाद, सह-अभाज्य (coprime) पूर्णांकों के जोड़े $(a, b)$ की बड़ी संख्या में खोज की जाती है। इसका उद्देश्य ऐसे जोड़े खोजना है जहाँ निम्नलिखित 2 मान “B-स्मूथ” (B-smooth, केवल अपेक्षाकृत छोटे अभाज्य गुणनखंडों से बने) हों:

$a - bm$ (पूर्णांक वलय पर मान)
$b^d f(a/b)$ (संख्या क्षेत्र पर मानदंड $N(a - b\alpha)$ के अनुरूप)

यहाँ “चलनी” (Sieve) नामक एक तेज़ खोज तकनीक का उपयोग किया जाता है। इसके द्वारा, विशाल उम्मीदवारों में से शर्तों को पूरा करने वाले $(a, b)$ जोड़ों को कुशलतापूर्वक निकाला जाता है।

2.3. मैट्रिक्स न्यूनीकरण (Linear Algebra over GF(2))

एकत्र किए गए जोड़े $(a, b)$ से, घातांक सदिश (exponent vectors) का निर्माण किया जाता है, और एक विशाल विरल मैट्रिक्स (sparse matrix) के बाएँ शून्य स्थान (left null space) को $\mathbb{F}_2$ (वह क्षेत्र जिसमें केवल 0 और 1 तत्व होते हैं) पर ज्ञात किया जाता है।

वेक्टर $v$ को एक समाधान के रूप में इस प्रकार खोजा जाता है कि संबंध $ \prod (a_i - b_i m) $ और $ \prod (a_i - b_i \alpha) $ दोनों वर्ग अवयव (square elements) बन जाएँ। यह,

$$ M \mathbf{x} \equiv \mathbf{0} \pmod 2 $$

जैसी रैखिक समीकरण प्रणाली को हल करने के अलावा और कुछ नहीं है। यहाँ, ब्लॉक लैंक्ज़ोस एल्गोरिदम (Block Lanczos Algorithm) या ब्लॉक विडमैन एल्गोरिदम (Block Wiedemann Algorithm) जैसे उन्नत संख्यात्मक संगणना एल्गोरिदम का उपयोग किया जाता है।

2.4. वर्गमूल की गणना

अंत में, संख्या क्षेत्र और पूर्णांक वलय दोनों में वर्गमूल लिया जाता है, और $x^2 \equiv y^2 \pmod N$ संबंध प्राप्त किया जाता है। फिर, $\gcd(x-y, N)$ की गणना की जाती है और गुणनखंड प्राप्त किया जाता है।

3. क्वांटम कंप्यूटिंग द्वारा सफलता: “शोर का एल्गोरिदम” (Shor’s Algorithm)

जबकि GNFS को उप-घातांकीय समय की आवश्यकता होती है, 1994 में पीटर शोर द्वारा प्रस्तुत किया गया “शोर का एल्गोरिदम” , क्वांटम कंप्यूटर का उपयोग करके इस समस्या को “बहुपद समय” (Polynomial Time) में हल कर सकता है।

शोर के एल्गोरिदम की समय जटिलता

जब क्यूबिट्स की संख्या $O(\log N)$ हो, तो समय जटिलता इस प्रकार होती है:

$$ O((\log N)^3) $$

इसका मतलब यह है कि यह बिट्स की संख्या के सापेक्ष घातांकीय विस्फोट नहीं करता है। यह एक आश्चर्यजनक परिणाम है कि “क्वांटम कंप्यूटिंग” कुछ घंटों से कुछ दिनों में उन विशाल भाज्य संख्याओं को डिक्रिप्ट कर सकता है, जिनकी “क्लासिकल कंप्यूटिंग” के लिए गणना का समय ब्रह्मांड के जीवनकाल से भी अधिक होगा।

शोर के एल्गोरिदम का समग्र दृश्य: आवर्त खोज समस्या (Period Finding Problem) में कमी

शोर का एल्गोरिदम अभाज्य गुणनखंडन समस्या को बड़ी चतुराई से “आवर्त खोज समस्या” में बदल देता है।

$N$ के साथ सह-अभाज्य एक यादृच्छिक पूर्णांक $a$ चुनें ($1 < a < N$)।
फलन $f(x) = a^x \bmod N$ परिभाषित करें।
$f(x)$ का आवर्त (period) $r$ खोजें, अर्थात वह सबसे छोटा धनात्मक पूर्णांक $r$ जिसके लिए $a^r \equiv 1 \pmod N$ हो।
यदि $r$ सम (even) है, तो जांचें कि क्या $a^{r/2} \not\equiv -1 \pmod N$ है, और अभाज्य गुणनखंड प्राप्त करने के लिए $\gcd(a^{r/2} \pm 1, N)$ की गणना करें।

चरण 3 में यह “आवर्त $r$ की खोज” ही वह बाधा है जिसमें क्लासिकल कंप्यूटर को घातांकीय समय लगता है, लेकिन क्वांटम कंप्यूटर “क्वांटम सुपरपोज़िशन” और “क्वांटम फूरियर ट्रांसफॉर्म” (QFT) का उपयोग करके इसे पल भर में हल कर देता है।

4. क्वांटम फूरियर ट्रांसफॉर्म (QFT) और आवर्त का निष्कर्षण

आइए शोर के एल्गोरिदम के मूल, क्वांटम अवस्थाओं (quantum states) के संचालन को गणितीय सूत्रों के माध्यम से विस्तार से देखें।

4.1. क्वांटम सुपरपोज़िशन का निर्माण

सबसे पहले, 2 क्वांटम रजिस्टर तैयार किए जाते हैं। रजिस्टर 1 इनपुट $x$ की सुपरपोज़िशन अवस्था (superposition state) रखता है, और रजिस्टर 2 फलन के गणना परिणाम $f(x)$ को रखता है। प्रारंभिक अवस्था $|0\rangle |0\rangle$ पर हैडामर्ड ट्रांसफॉर्म (Hadamard Transform) लागू करके सभी संभावित $x$ का सुपरपोज़िशन बनाया जाता है।

$$ |\psi_1\rangle = \frac{1}{\sqrt{Q}} \sum_{x=0}^{Q-1} |x\rangle |0\rangle $$

(यहाँ $Q$, $N^2 \le Q < 2N^2$ को पूरा करने वाली 2 की घात है)

इसके बाद, क्वांटम ओरेकल $U_f$ का उपयोग करके $f(x) = a^x \bmod N$ की गणना की जाती है और इसे रजिस्टर 2 में संग्रहीत किया जाता है।

$$ |\psi_2\rangle = U_f |\psi_1\rangle = \frac{1}{\sqrt{Q}} \sum_{x=0}^{Q-1} |x\rangle |a^x \bmod N\rangle $$

यहाँ मान लीजिए कि रजिस्टर 2 को मापा गया है (वास्तव में इसे मापे बिना भी गणितीय संरचना समान रहती है)। यदि कोई मान $y = a^{x_0} \bmod N$ देखा जाता है, तो रजिस्टर 1 की अवस्था उन सभी $x$ के सुपरपोज़िशन में सिमट (collapse) जाती है जिनके लिए $f(x) = y$ होता है। यदि आवर्त $r$ है, तो ऐसे $x$, $x_0, x_0 + r, x_0 + 2r, \dots$ होंगे।

$$ |\psi_3\rangle = \frac{1}{\sqrt{M}} \sum_{k=0}^{M-1} |x_0 + kr\rangle $$

(यहाँ $M \approx Q/r$ पदों की संख्या है)

यह अवस्था आवर्त $r$ की जानकारी को अंतर्निहित रखती है, लेकिन इसे सीधे मापने पर केवल एक यादृच्छिक (random) $x_0 + kr$ प्राप्त होगा, और आवर्त $r$ ज्ञात नहीं होगा। यहीं पर QFT काम आता है।

4.2. क्वांटम फूरियर ट्रांसफॉर्म (Quantum Fourier Transform) लागू करना

QFT एक ऐसा ऑपरेशन है जो क्वांटम अवस्थाओं के आयामों (amplitudes) पर असतत फूरियर ट्रांसफॉर्म (Discrete Fourier Transform) करता है। अवस्था $|x\rangle$ पर QFT की क्रिया को इस प्रकार परिभाषित किया गया है:

$$ \text{QFT} |x\rangle = \frac{1}{\sqrt{Q}} \sum_{y=0}^{Q-1} e^{2\pi i \frac{xy}{Q}} |y\rangle $$

जब इसे $|\psi_3\rangle$ पर लागू किया जाता है, तो चरण हस्तक्षेप (क्वांटम इंटरफेरेंस) होता है।

$$ |\psi_4\rangle = \text{QFT} |\psi_3\rangle = \frac{1}{\sqrt{MQ}} \sum_{y=0}^{Q-1} \sum_{k=0}^{M-1} e^{2\pi i \frac{(x_0 + kr)y}{Q}} |y\rangle $$

इस समीकरण के योग का विस्तार करने पर,

$$ \sum_{k=0}^{M-1} e^{2\pi i \frac{kry}{Q}} $$

यह भाग प्रकट होता है। इस ज्यामितीय श्रेणी का योग केवल तभी एक-दूसरे को मजबूत करता है (Constructive Interference) जब $ry/Q$ एक पूर्णांक के करीब होता है, और अन्य समय में यह एक-दूसरे को रद्द (Destructive Interference) कर देता है।

इसलिए, उच्च संभावना के साथ मापी जाने वाली अवस्था $|y\rangle$ वह होगी जिसके लिए,

$$ \frac{y}{Q} \approx \frac{c}{r} $$

शर्त को पूरा करने वाला पूर्णांक $y$ हो ($c$ कोई पूर्णांक है)।

4.3. निरंतर भिन्न विस्तार (Continued Fraction Expansion) द्वारा आवर्त की पहचान

माप से $y$ प्राप्त करने के बाद, क्लासिकल कंप्यूटर का उपयोग करके $y/Q$ का “निरंतर भिन्न विस्तार” (Continued Fraction Expansion) किया जाता है। इसके द्वारा, $y/Q$ के अनुमानित भिन्न $c/r$ की गणना की जाती है, और हर (denominator) से आवर्त $r$ के उम्मीदवार को अत्यधिक कुशलता से निकाला जा सकता है।

5. वैचारिक मॉडल की तुलना और पैराडाइम शिफ्ट

GNFS और शोर के एल्गोरिदम के बीच के अंतर को सहज रूप से समझने के लिए, Mermaid सिंटैक्स का उपयोग करके एक वैचारिक आरेख (concept diagram) नीचे दिया गया है।

क्वांटम सर्किट द्वारा शोर के एल्गोरिदम का वैचारिक आरेख

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


graph TD
 A[प्रारंभिक अवस्था: 0...0] --> B[Hadamard ट्रांसफॉर्म द्वारा सभी अवस्थाओं का सुपरपोज़िशन]
 B --> C[मॉड्यूलर घातांक गणना a^x mod N]
 C -->|क्वांटम एंटैंगलमेंट| D[आवधिकता (periodicity) वाली अवस्था में सिमटना]
 D --> E[क्वांटम फूरियर ट्रांसफॉर्म QFT]
 E -->|हस्तक्षेप (Interference) द्वारा प्रायिकता प्रवर्धन| F[माप: y प्राप्त करना]
 F --> G[क्लासिकल प्रक्रिया: निरंतर भिन्न विस्तार]
 G --> H[आवर्त r की खोज]
 H --> I[N के अभाज्य गुणनखंडों की गणना]

 style A fill:#f9f,stroke:#333,stroke-width:2px
 style E fill:#bbf,stroke:#333,stroke-width:2px
 style I fill:#bfb,stroke:#333,stroke-width:2px

पैराडाइम शिफ्ट का सार

GNFS “गणितीय स्थान (संख्या क्षेत्र) में संबंधों को खोजने” का दृष्टिकोण अपनाता है। हालाँकि, चूँकि खोज स्थान अंकों की संख्या के सापेक्ष घातांकीय रूप से फैलता है, इसलिए क्लासिकल कंप्यूटर की गणना क्षमता (समानांतरकरण सहित) के साथ, जब कुंजी की लंबाई 2048 बिट्स आदि से अधिक हो जाती है तो इसे डिक्रिप्ट करना लगभग असंभव हो जाता है।

दूसरी ओर, शोर का एल्गोरिदम “क्वांटम हस्तक्षेप के कारण तरंग गुणों” का उपयोग करता है। यह सुपरपोज़िशन अवस्था में सभी गणना पथों (computation paths) का एक साथ मूल्यांकन करता है, और QFT द्वारा अवांछित उत्तरों को रद्द (Destructive Interference) कर देता है, तथा केवल सही उत्तर वाले आवर्त के प्रायिकता आयाम (probability amplitude) को प्रवर्धित (Constructive Interference) करता है। इससे यह स्थान को खोजने के बजाय, “सही उत्तर को ही सामने लाने” के एक बिल्कुल अलग आयाम का दृष्टिकोण प्राप्त करता है।

6. निष्कर्ष

इस लेख में, हमने क्लासिकल सीमाओं की चरम सीमा “GNFS” और क्वांटम कंप्यूटिंग की शक्ति प्रदर्शित करने वाले “शोर के एल्गोरिदम” के गणितीय पृष्ठभूमि और एल्गोरिथम संरचना की गहराई से तुलना की है।

जबकि GNFS ने बहुपद चयन और विशाल मैट्रिक्स गणना जैसी गणितीय तकनीकों का उपयोग करके समय जटिलता को उप-घातांकीय समय तक कम किया, शोर के एल्गोरिदम ने क्वांटम यांत्रिकी के मूल सिद्धांतों, सुपरपोज़िशन और हस्तक्षेप को गणितीय उपकरण (QFT) के साथ मिलाया, और एक ही झटके में बहुपद समय की सफलता प्राप्त की।

वर्तमान में, व्यावहारिक पैमाने (हजारों क्यूबिट्स) पर शोर के एल्गोरिदम को चलाने में सक्षम कोई दोष-सहिष्णु क्वांटम कंप्यूटर (Fault-Tolerant Quantum Computer, FTQC) मौजूद नहीं है। हालाँकि, इस गणितीय और सैद्धांतिक पैराडाइम शिफ्ट का अस्तित्व ही वह सबसे बड़ा कारण है कि वर्तमान में दुनिया भर में पोस्ट-क्वांटम क्रिप्टोग्राफी (PQC) की ओर संक्रमण में तेज़ी आ रही है।