GNFS on kenji.blog

【संपूर्ण विश्लेषण】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++ फ्रेमवर्क के माध्यम से, आप अत्याधुनिक क्रिप्टोग्राफी क्रैकिंग एल्गोरिदम के पीछे “गणित और कंप्यूटर के रोमांस” को महसूस करेंगे।

सामान्य संख्या क्षेत्र चलनी (GNFS) की सच्ची गणितीय संरचना

Sat, 05 Sep 2026 02:26:13 +0900

सामान्य संख्या क्षेत्र चलनी (GNFS) की सच्ची गणितीय संरचना

GNFS का अंतिम उद्देश्य $X, Y$ खोजना है ताकि $X^2 \equiv Y^2 \pmod N$ हो सके। इसे प्राप्त करने के लिए, गणितज्ञों ने “वास्तविक पूर्णांकों की दुनिया” और “बीजगणितीय क्षेत्रों की दुनिया” के बीच एक पुल बनाया। वह पुल “होमोमोर्फिज़्म (Homomorphism)” है।

चरण 1: दुनियाओं को जोड़ने वाला “होमोमोर्फिज़्म”

1. बहुपद का चयन और जड़ों की परिभाषा

एक विशाल भाज्य संख्या $N$ के लिए, हम एक पूर्णांक $m$ और एक बहुपद $f(x)$ चुनते हैं ताकि $f(m) \equiv 0 \pmod N$ हो। (उदाहरण: $N$ को $m$ के आधार पर विस्तारित करें और इसके गुणांकों से $f(x)$ बनाएँ। यहाँ हम मान लेते हैं कि $f(x)$ परिमेय संख्याओं के क्षेत्र $\mathbb{Q}$ पर अप्राप्य (irreducible) है (इसे और फ़ैक्टर नहीं किया जा सकता))।

अगला, हम समीकरण $f(x) = 0$ की “जटिल संख्याओं में जड़ों” में से एक को $\alpha$ के रूप में परिभाषित करते हैं। स्वाभाविक रूप से, $f(\alpha) = 0$ है। $\alpha$ एक पूर्णांक नहीं है, बल्कि एक जटिल संख्या है जिसमें वर्गमूल और काल्पनिक संख्याएँ शामिल हैं (एक बीजगणितीय संख्या)।

2. रिंग (Ring) और होमोमोर्फिज़्म का निर्माण

यहाँ, हम दो गणितीय “रिंग” (वे दुनिया जहाँ जोड़ और गुणा परिभाषित हैं) तैयार करते हैं।

दुनिया A: $\mathbb{Z}[\alpha]$ (बीजगणितीय पूर्णांकों की रिंग जिसमें $\alpha$ शामिल है) यह $a + b\alpha + c\alpha^2 + \dots$ के रूप में व्यक्त संख्याओं की दुनिया है।
दुनिया B: $\mathbb{Z}/N\mathbb{Z}$ ($N$ से भाग देने पर शेषफल की रिंग) यह केवल $0$ से $N-1$ तक के पूर्णांकों से बनी सर्वांगसमता (modulo) की दुनिया है।

यहाँ, हम दुनिया A से दुनिया B तक निम्नलिखित मैपिंग $\phi$ को परिभाषित करते हैं। $$\phi : \mathbb{Z}[\alpha] \to \mathbb{Z}/N\mathbb{Z}$$ $$\phi(\alpha) = m \pmod N$$

यह मैपिंग $\phi$ एक जादुई ऑपरेशन है जो दुनिया A के चर $\alpha$ को दुनिया B के पूर्णांक $m$ से बदल देता है। इस $\phi$ में एक अत्यंत शक्तिशाली गुण है जिसे “रिंग होमोमोर्फिज़्म (Ring Homomorphism)” कहा जाता है। होमोमोर्फिज़्म का अर्थ है “जोड़ और गुणा की संरचना को नष्ट किए बिना किसी दूसरी दुनिया में टेलीपोर्ट करना” । दूसरे शब्दों में, निम्नलिखित समीकरण सत्य हैं:

$\phi(X \times Y) = \phi(X) \times \phi(Y)$
$\phi(X^2) = \phi(X)^2$

इसका क्या मतलब है? अगर हम “दुनिया A ($\alpha$ की दुनिया)” में किसी जटिल तत्व $\gamma$ का “वर्ग ($\gamma^2$)” बना सकते हैं, और इसे $\phi$ का उपयोग करके “दुनिया B (शेषफल की दुनिया)” में टेलीपोर्ट कर सकते हैं, तो वर्ग रूप $\phi(\gamma)^2$ पूरी तरह से संरक्षित रहता है ।

चरण 2: अभाज्य गुणनखंडन का पतन और “आदर्शों (Ideals)” का जन्म

हम दुनिया A ($\mathbb{Z}[\alpha]$) में कई उपयुक्त तत्वों $(a - b\alpha)$ को इकट्ठा करना चाहते हैं, और उन्हें गुणा करके एक “पूर्ण वर्ग (वर्ग तत्व)” बनाना चाहते हैं। आम तौर पर, हम प्रत्येक $(a - b\alpha)$ को “अभाज्य गुणनखंड (prime factorization)” करेंगे और उन्हें इस तरह जोड़ेंगे कि अभाज्य संख्याओं के घातांक सभी सम (even) हों (मैट्रिक्स के साथ हल करके) ताकि एक वर्ग बनाया जा सके।

हालाँकि, यहाँ बीजगणित की निराशाजनक दीवार खड़ी है। $\mathbb{Z}[\alpha]$ जैसी बीजगणितीय दुनिया में, मिडिल स्कूल में सिखाई गई “अभाज्य गुणनखंडन की विशिष्टता (किसी भी संख्या को विशिष्ट रूप से अभाज्य संख्याओं के उत्पाद के रूप में व्यक्त किया जा सकता है)” ढह जाती है ।

(उदाहरण: एक निश्चित बीजगणितीय क्षेत्र की दुनिया में, $6 = 2 \times 3$ है, और साथ ही $6 = (1+\sqrt{-5}) \times (1-\sqrt{-5})$ है, और हम यह नहीं जानते कि कौन सा असली अभाज्य है)

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

कुमेर और डेडेकिंड का बचाव: “आदर्श (Ideal)”

इस पतन से जो बचाया गया, वह 19वीं सदी के गणितज्ञों द्वारा बनाई गई “आदर्श (Ideal: आदर्श संख्या)” की अवधारणा थी। तत्व के बजाय, तत्व द्वारा उत्पन्न “गुणकों के सेट (आदर्श)” पर विचार करके, अभाज्य गुणनखंडन फिर से संभव हो गया।

एक बीजगणितीय क्षेत्र की पूर्णांक रिंग $\mathcal{O}_K$ ($\mathbb{Z}[\alpha]$ सहित अधिक पूर्ण रिंग) में, यह सिद्ध होता है कि भले ही तत्वों को विशिष्ट रूप से गुणनखंडित नहीं किया जा सकता, “एक आदर्श को हमेशा ‘अभाज्य आदर्शों ($\mathfrak{p}$)’ के उत्पाद के रूप में विशिष्ट रूप से गुणनखंडित किया जा सकता है” ।

इसलिए GNFS में, तत्व $(a - b\alpha)$ को सीधे गुणनखंडित करने के बजाय, हम इसके द्वारा उत्पन्न प्रमुख आदर्श (principal ideal) $\langle a - b\alpha \rangle$ को अभाज्य आदर्शों में गुणनखंडित करते हैं ।

चरण 3: नॉर्म (Norm) और दो चलनियां (Sieves)

तो, हम कैसे जानेंगे कि आदर्श $\langle a - b\alpha \rangle$ किन अभाज्य आदर्शों में विघटित होगा? यहाँ हम “नॉर्म (Norm)” नामक फ़ंक्शन का उपयोग करते हैं। नॉर्म एक ऐसा फ़ंक्शन है जो बीजगणितीय क्षेत्रों के जटिल तत्वों को “सामान्य वास्तविक पूर्णांकों $\mathbb{Z}$” में परिवर्तित करता है।

तत्व $(a - b\alpha)$ का नॉर्म एक साधारण बहुपद गणना $b^d f(a/b)$ द्वारा पाया जाता है ($d$, $f(x)$ की डिग्री है)।

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

इसलिए GNFS पूर्णांक युग्मों $(a, b)$ की एक बड़ी संख्या के लिए निम्नलिखित दो की एक साथ गणना करता है, और केवल उन युग्मों को एकत्र करता है जहाँ दोनों “चिकनी संख्या (smooth number)” बन जाते हैं:

परिमेय चलनी (Rational Sieve) : $a - bm$ (वास्तविक दुनिया में मान)
बीजगणितीय चलनी (Algebraic Sieve) : $b^d f(a/b)$ (बीजगणितीय दुनिया में नॉर्म)

दशकों लाख युग्मों $(a, b)$ को इकट्ठा करने के बाद, हम अभाज्य आदर्श गुणनखंडन डेटा (कितने अभाज्य आदर्श शामिल हैं) को एक विशाल मैट्रिक्स (GF(2) पर रैखिक बीजगणित) के रूप में हल करते हैं ताकि युग्मों का एक सेट $S$ मिल सके जहाँ “गुणा करने पर सभी अभाज्य आदर्शों के घातांक सम हो जाते हैं”।

चरण 4: दो “बाधाएं” और आदर्श वर्ग समूह (Ideal Class Group)

मैट्रिक्स गणना से, हमने पाया कि सेट $S$ से संबंधित सभी $(a - b\alpha)$ के आदर्शों को गुणा करने पर एक निश्चित आदर्श $I$ का वर्ग प्राप्त होता है।

$$\prod_{S} \langle a - b\alpha \rangle = I^2$$

हालाँकि, यह अभी खत्म नहीं हुआ है। GNFS में सबसे गहरी और सबसे कठिन गणितीय दीवार यहीं है।

अंत में हम “आदर्श का वर्ग” नहीं चाहते हैं, बल्कि मैपिंग $\phi$ में बदलने के लिए “तत्व का वर्ग ($\gamma^2$)” चाहते हैं। सिर्फ इसलिए कि यह एक आदर्श का वर्ग बन गया, इसका मतलब यह नहीं है कि तत्व भी एक वर्ग है। यहाँ दो मजबूत गणितीय बाधाएं (Obstructions) हैं।

बाधा ①: आदर्श वर्ग समूह (Ideal Class Group) की दीवार

आदर्श $I$ हमेशा “एक ही तत्व द्वारा उत्पन्न आदर्श (प्रमुख आदर्श)” नहीं होता है। गैर-प्रमुख आदर्शों से किसी विशिष्ट तत्व $\gamma$ को निकालना असंभव है।

यहाँ “आदर्श वर्ग समूह (Class Group, $Cl_K$)” की अवधारणा आती है। आदर्श वर्ग समूह एक ऐसा समूह है जो यह मापता है कि “उस बीजगणितीय क्षेत्र की दुनिया में कितने आदर्श हैं जो प्रमुख नहीं हैं (अभाज्य गुणनखंडन की विशिष्टता कितनी टूट गई है)"। भले ही $\prod \langle a - b\alpha \rangle$, $I^2$ बन जाए, यदि $I$ आदर्श वर्ग समूह में पहचान तत्व (प्रमुख आदर्श) नहीं है, तो इसे तत्व के वर्ग में वापस नहीं लाया जा सकता है।

बाधा ②: इकाई समूह (Unit Group) की दीवार

मान लीजिए कि सौभाग्य से $I$ प्रमुख आदर्श $\langle \gamma \rangle$ है। तब, $\prod \langle a - b\alpha \rangle = \langle \gamma^2 \rangle$ होता है। आप सोच सकते हैं, “बहुत बढ़िया, तत्व भी एक वर्ग है!”, लेकिन यह एक बड़ी गलती है।

आदर्शों (गुणकों के सेट) के समान होने का मतलब यह नहीं है कि तत्व पूरी तरह से समान हैं। हमेशा एक “इकाई (Unit: एक ऐसी संख्या जिसका व्युत्क्रम भी एक पूर्णांक है। जैसे 1 या -1)” का विचलन होगा। दूसरे शब्दों में, वास्तविक तत्व समीकरण इस प्रकार बन जाता है:

$$\prod_{S} (a - b\alpha) = u \cdot \gamma^2$$

($u$ इकाई समूह $U_K$ का एक तत्व है)

जब तक यह इकाई $u$ स्वयं किसी चीज़ का वर्ग नहीं है, तब तक बायाँ पक्ष कभी भी “सही तत्व का वर्ग” नहीं बन सकता।

चरण 5: एडलमैन का जादू “द्विघात वर्ण (Quadratic Characters)”

आदर्श वर्ग समूह की बाधा और इकाई समूह की बाधा। इन दोनों को कैसे पार करें? यहाँ क्रिप्टोग्राफर लियोनार्ड एडलमैन (RSA का “A”) और अन्य लोगों द्वारा पेश की गई शानदार विधि “द्विघात वर्ण (Quadratic Characters)” आती है।

यह निर्धारित करने के लिए कि “क्या बीजगणितीय क्षेत्र में कोई निश्चित तत्व पूर्ण वर्ग है?”, हम लीजेंड्रे प्रतीक (द्विघात अवशेष) के बीजगणितीय क्षेत्र संस्करण का उपयोग करते हैं। उस विशाल मैट्रिक्स (अभाज्य आदर्शों की संख्या को सम बनाने के लिए पहेली) में, हम चुपके से दर्जनों अतिरिक्त शर्तें (कॉलम) जोड़ते हैं, जिसमें कहा गया है कि “कुछ विशेष अभाज्य आदर्शों $\mathfrak{q}$ के लिए द्विघात वर्ण भी सभी $1$ (सम) होने चाहिए” ।

जब हम मैट्रिक्स गणना द्वारा इन अतिरिक्त शर्तों को भी पूरा करने वाला एक सेट $S$ खोजते हैं, तो बीजगणितीय संख्या सिद्धांत के गहरे प्रमेयों द्वारा यह गारंटी दी जाती है कि “आदर्श वर्ग समूह की बाधा और इकाई समूह की बाधा दोनों ही भारी संभावना के साथ स्वाभाविक रूप से गायब हो जाएंगे” ।

इसके साथ, अंततः हमें सच्चा समीकरण मिल जाता है:

$$\prod_{S} (a - b\alpha) = \gamma^2$$

अंतिम चरण: दुनियाओं का विलय और क्रिप्टोग्राफ़िक पतन

अंत में, पहेली के सभी टुकड़े अपनी जगह पर हैं।

[बीजगणितीय क्षेत्रों की दुनिया में तत्व (दुनिया A)] $\gamma^2 = \prod (a - b\alpha)$ (हम $\gamma$ खोजने के लिए वर्गमूल एल्गोरिदम का उपयोग करते हैं)

[वास्तविक दुनिया में तत्व (परिमेय संख्याओं की दुनिया)] $V^2 = \prod (a - bm)$ (चूंकि यह साधारण पूर्णांक गुणन है, हम आसानी से वर्गमूल $V$ पा सकते हैं)

अब, उस जादुई पुल का समय आ गया है जिसे हमने शुरुआत में बनाया था, होमोमोर्फिज़्म $\phi$ । हम $\phi$ ($\alpha$ को $m$ से बदलने वाला मैपिंग) का उपयोग करके दुनिया A के तत्व $\gamma$ को दुनिया B ($N$ के शेषफल की दुनिया) में टेलीपोर्ट करते हैं।

$$Y = \phi(\gamma) \pmod N$$

दूसरी ओर, हम वास्तविक दुनिया में बनाए गए $V$ को सीधे शेषफल की दुनिया में लाते हैं और इसे $X$ कहते हैं।

$$X = V \pmod N$$

होमोमोर्फिज़्म की “संरचना संरक्षण” संपत्ति के कारण, दुनिया A में वर्ग संबंध दुनिया B (मोडुलो $N$ की दुनिया) में पूरी तरह से संरक्षित है। इसके अलावा, चूंकि मूल युग्म $(a, b)$, $a - b\alpha$ और $a - bm$ के रूप में बनाए गए थे, ये $X$ और $Y$ मोडुलो $N$ की दुनिया में टकराते हैं और निम्नलिखित पूर्ण समीकरण उत्पन्न करते हैं:

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

अब हमें बस यह प्रार्थना करनी है कि ये $X$ और $Y$ तुच्छ समाधान ($X \equiv \pm Y$) न हों, और $\gcd(X - Y, N)$ की गणना करें।

यदि यह एक गैर-तुच्छ समाधान है, तो यूक्लिड का एल्गोरिदम 0.001 सेकंड में चलेगा, और RSA क्रिप्टोग्राफी का दिल कहे जाने वाले गुप्त अभाज्य $p$ और $q$ आउटपुट स्क्रीन पर छप जाएंगे।

यह आधुनिक गणित के सार का संग्रह, “सामान्य संख्या क्षेत्र चलनी (GNFS)” की पूरी तस्वीर है।

इंटरनेट एन्क्रिप्शन को तोड़ने वाला मानवता का सबसे शक्तिशाली गणित "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 की गणना उच्च विश्वविद्यालय गणित, जैसे बीजीय संख्या क्षेत्रों के आदर्श वर्ग समूहों और समरूपता का उपयोग करके सख्ती से की जाती है)

[गणितीय सूत्रों से पूर्ण समझ] क्लासिकल में सबसे शक्तिशाली '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) की ओर संक्रमण में तेज़ी आ रही है।