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

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

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]

今すぐ購入

P≠NP अनुमान

Wed, 11 Sep 2024 02:22:39 +0900

अवलोकन

1

क्लास P, नियतात्मक ट्यूरिंग मशीन (deterministic Turing machine) में बहुपद समय (polynomial time) में तय की जा सकने वाली समस्याओं का वर्ग है, और क्लास NP उन समस्याओं का वर्ग है जिसमें, यदि हाँ (Yes) होने का प्रमाण (जिसे Witness कहा जाता है) दिया जाता है, तो बहुपद समय में Witness की वैधता को जाँचा जा सकता है (इसे सत्यापन कहा जाता है)। चूँकि बहुपद समय में तय की जा सकने वाली समस्याओं को बहुपद समय में सत्यापित किया जा सकता है, यह स्पष्ट है कि P⊆NP, लेकिन यह स्पष्ट नहीं है कि P, NP का उचित उपसमुच्चय (proper subset) है या नहीं। अभी तक कोई प्रमाण नहीं है, लेकिन कई शोधकर्ताओं का मानना है कि P≠NP है। और यह अनुमान कि यह क्लास P और क्लास NP समान नहीं हैं, "P≠NP अनुमान" कहलाता है।

संदर्भ साइट : https://daigakudenki.com/np-hard/

अभाज्य संख्याएँ उत्पन्न करने के लिए 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}

बर्थडे पैराडॉक्स क्या है?

Tue, 02 Apr 2024 01:20:50 +0900

क्या आप बर्थडे पैराडॉक्स के बारे में जानते हैं?

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

उदाहरण के लिए, एक वर्ष में 365 दिन होते हैं, इसलिए जब आपको बताया जाता है कि “यदि 23 लोग इकट्ठा होते हैं, तो किसी के साथ जन्मदिन साझा करने की संभावना 50% से अधिक है”… यह कुछ हद तक अंतर्ज्ञान के विरुद्ध लगता है।

लेकिन यह वास्तव में 50% से अधिक है।

ऐसा क्यों होता है?

इस घटना को “बर्थडे पैराडॉक्स” कहा जाता है। नाम “विरोधाभास (पैराडॉक्स)” है, लेकिन इसका एक उचित गणितीय कारण है।

जब लोगों की संख्या “n” होती है, तो किसी का भी जन्मदिन समान न होने की संभावना की गणना निम्नलिखित सूत्र द्वारा की जा सकती है:

1

P(कोई समान नहीं) = 365/365 × 364/365 × 363/365 × ... × (365 - n + 1)/365

इसे 1 से घटाने पर, “किसी के साथ समान होने की संभावना” सामने आती है।

आइए परिणाम देखें…

लोगों की संख्या	समान जन्मदिन वाले लोगों की संभावना
10 लोग	लगभग 11.7%
20 लोग	लगभग 41.1%
23 लोग	लगभग 50.7% (यहाँ ध्यान दें!)
30 लोग	लगभग 70.6%
70 लोग	आश्चर्यजनक रूप से लगभग 99.9%!

यानी, केवल 23 लोगों के होने पर, आधे से अधिक संभावना है कि किसी का जन्मदिन समान होगा। स्कूल की कक्षा या काम पर बैठक में भी यह काफी लागू होता है।

निष्कर्ष: अंतर्ज्ञान और गणित के बीच का अंतर दिलचस्प है

“बर्थडे पैराडॉक्स” एक दिलचस्प उदाहरण है कि हमारा अंतर्ज्ञान और वास्तविक गणितीय संभावना कैसे भिन्न होती है। इस तरह की बातें जानने से छोटी बातचीत और क्विज़ मज़ेदार हो सकते हैं!

संदर्भ लिंक

जन्मदिन का विरोधाभास (Wikipedia)

मोंटी हॉल समस्या

Sun, 31 Mar 2024 23:41:51 +0900

मोंटी हॉल समस्या क्या है?

मोंटी हॉल समस्या एक अमेरिकी टेलीविजन शो “Let’s Make a Deal” में खेले जाने वाले गेम से प्रेरित है, और यह इस प्रकार है:

पूर्व शर्तें: 3 दरवाजों में से 1 के पीछे एक पुरस्कार है, और बाकी 2 के पीछे कुछ नहीं है।

प्रतिभागी 3 दरवाजों में से 1 को चुनता है।
होस्ट, प्रतिभागी द्वारा नहीं चुने गए 2 दरवाजों में से 1 दरवाजा खोलता है, जिसके पीछे कुछ नहीं होता।
प्रतिभागी से पूछा जाता है कि क्या वे अपना चुना हुआ दरवाजा बदलना चाहते हैं।

इस समय, समस्या यह सोचना है कि प्रतिभागी के लिए दरवाजा बदलना बेहतर है या नहीं।

समाधान

मोंटी हॉल समस्या का समाधान इस प्रकार है:

यदि प्रतिभागी अपना प्रारंभिक चुना हुआ दरवाजा नहीं बदलता है
- जीतने की प्रायिकता: 1/3
- हारने की प्रायिकता: 2/3
होस्ट द्वारा खाली दरवाजा खोलने के बाद
- यदि नहीं बदलता है, जीतने की प्रायिकता: 1/3 (1. की जीतने की प्रायिकता से अपरिवर्तित)
- यदि बदलता है, जीतने की प्रायिकता: 2/3 (1. में जीतने के अलावा की प्रायिकता)

इसलिए, यदि प्रतिभागी दरवाजा बदलता है तो जीतने की प्रायिकता अधिक होती है।

संदर्भ

विकिपीडिया Monty Hall problem

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

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$$

गणित का इतिहास

Sat, 22 Jul 2023 15:25:10 +0900

प्राचीन ग्रीस की तीन शास्त्रीय निर्माण समस्याएं

एक वृत्त दिए जाने पर, उसके समान क्षेत्रफल वाले वर्ग का निर्माण करना (वृत्त का वर्गाकार करना)
किसी भी दिए गए कोण को तीन बराबर भागों में विभाजित करना (कोण का त्रिभाजन)
एक घन दिए जाने पर, उसके दोगुने आयतन वाले घन का निर्माण करना (घन का द्विगुणन)

आर्किमिडीज़ का सर्पिल

एक तल पर, एक किरण OB एक निश्चित बिंदु O के चारों ओर एक समान गति से घूमती है। यदि प्रारंभिक स्थिति OA है, और उसी समय बिंदु P, O से शुरू होकर OB के साथ निरंतर गति से आगे बढ़ता है, तो बिंदु P द्वारा खींची गई रेखा आर्किमिडीज़ का सर्पिल है।

पप्पस का प्रमेय

साइक्लोइड
निकोमेडीज का कॉन्कोइड
डायोक्लेस का सिसॉयड
फर्मेट की स्पर्शरेखा विधि
डेसकार्टेस की सामान्य विधि

कालक्रम

वर्ष	घटना
लगभग 3400 ईसा पूर्व	सुमेरियन लेखांकन के लिए मिट्टी के टोकन का उपयोग करते हैं
लगभग 3000 ईसा पूर्व	मिस्र में चित्रलिपि गणित का उदय
लगभग 2800 ईसा पूर्व	सिंधु घाटी सभ्यता में दशमलव प्रणाली पर आधारित वजन और माप का उपयोग
लगभग 2700 ईसा पूर्व	मिस्रवासी कोणों की पुष्टि करने के लिए रस्सियों और पाइथागोरस त्रिक का उपयोग करते हैं
लगभग 2500 ईसा पूर्व	गणना के लिए उपयोग किया जाने वाला उपकरण, अबैकस, खोजा गया
लगभग 2500 ईसा पूर्व

संदर्भ

गणित का इतिहास

इरेटोस्थनीज की छलनी का उपयोग करके 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

ह्यूगो (hugo) में KaTeX (LaTeX-शैली गणित सूत्र प्रदर्शन) को कैसे सक्षम करें

Fri, 31 Mar 2023 23:11:26 +0900

KaTeX क्या है

KaTeX HTML में LaTeX-शैली के गणित सूत्रों को प्रदर्शित करने के लिए एक जावास्क्रिप्ट (javascript) लाइब्रेरी है।

विशेष रूप से, आप नीचे दिए गए जैसे गणित सूत्र प्रदर्शित कर सकते हैं।

$$f(x) = x^2 + x + 41$$

LaTeX-शैली के अन्य गणित सूत्र प्रदर्शन पुस्तकालय भी प्रतीत होते हैं, लेकिन KaTeX अपनी सादगी और गति के लिए जाना जाता है।

hugo में कैसे शामिल करें

hugo के फ़ोल्डर पदानुक्रम में एक नया layouts/partials/math.html बनाएँ।

सामग्री इस प्रकार होनी चाहिए।

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


<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/katex@0.16.4/dist/katex.min.css" integrity="sha384-vKruj+a13U8yHIkAyGgK1J3ArTLzrFGBbBc0tDp4ad/EyewESeXE/Iv67Aj8gKZ0" crossorigin="anonymous">
<script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.4/dist/katex.min.js" integrity="sha384-PwRUT/YqbnEjkZO0zZxNqcxACrXe+j766U2amXcgMg5457rve2Y7I6ZJSm2A0mS4" crossorigin="anonymous"></script>
<script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.4/dist/contrib/auto-render.min.js" integrity="sha384-+VBxd3r6XgURycqtZ117nYw44OOcIax56Z4dCRWbxyPt0Koah1uHoK0o4+/RRE05" crossorigin="anonymous"></script>
<script>
document.addEventListener("DOMContentLoaded", function() {
 renderMathInElement(
 document.body,
 {
 delimiters: [
 {left: "$$", right: "$$", display: true},
 {left: "\\[", right: "\\]", display: true},
 {left: "$", right: "$", display: false},
 {left: "\\(", right: "\\)", display: false}
 ]
 });
 });
</script>

इसके बाद, मौजूदा फ़ाइल layouts/partials/extend_head.html में निम्नलिखित कोड जोड़ें।

1
2
3


{{ if or .Params.math .Site.Params.math }}
{{ partial "math.html" . }}
{{ end }}

अब आप KaTeX का उपयोग करने के लिए तैयार हैं।

आप पेज के front matter में math: true जोड़कर KaTeX को सक्षम कर सकते हैं।

इसके बाद आपको बस पेज लेख के मुख्य भाग में LaTeX-शैली में सूत्र लिखना है।

1

$$ e^{i \pi} = -1 $$

जैसा कि ऊपर लिखा गया है, यह नीचे दिए गए अनुसार प्रदर्शित होगा।

$$ e^{i \pi} = -1 $$

संदर्भ

Mathematica के साथ ट्रैवलिंग सेल्समैन समस्या को हल करना

Wed, 12 Oct 2022 19:05:58 +0900

Mathematica के साथ ट्रैवलिंग सेल्समैन समस्या को हल करना

समस्या

電車でこんな広告を見かけました😁📸 pic.twitter.com/iXEgvtXrpL
— 早稲田大学早水桃子研究室 (@hayamizu_lab) October 11, 2022

उपाय

1

d=SparseArray[{{1,2}->10,{2,1}->10,{1,5}->15,{5,1}->15,{1,4}->12,{4,1}->12,{1,3}->20,{3,1}->20,{2,5}->10,{5,2}->10,{3,4}->10,{4,3}->10,{3,8}->30,{8,3}->30,{3,7}->20,{7,3}->20,{3,6}->25,{6,3}->25,{4,5}->15,{5,4}->15,{4,8}->20,{8,4}->20,{5,9}->18,{9,5}->18,{5,8}->15,{8,5}->15,{6,7}->5,{7,6}->5,{7,8}->35,{8,7}->35,{8,9}->12,{9,8}->12},{9,9},Infinity];

SparseArray फ़ंक्शन का उपयोग करके एक मैट्रिक्स बनाएं। प्रत्येक तत्व उस तत्व की पंक्ति और कॉलम में शहरों के बीच की दूरी का प्रतिनिधित्व करता है। उदाहरण के लिए, पहले तत्व {1,2}->10 का अर्थ है कि 1 और 2 के बीच की दूरी 10 है। दूसरा-से-अंतिम तत्व {9,9} मैट्रिक्स के आकार को इंगित करता है, और अंतिम तत्व Infinity का अर्थ है कि अनिर्दिष्ट शहरों के बीच पथ की लंबाई अनंत है। दूसरे शब्दों में, इसका मतलब है कि कोई रास्ता नहीं है।

1

{len,tour}=FindShortestTour[{1,2,3,4,5,6,7,8,9},DistanceFunction->(d[[#1,#2]]&)]

FindShortestTour फ़ंक्शन के साथ, आप ट्रैवलिंग सेल्समैन समस्या को आसानी से हल कर सकते हैं। {1,2,3,4,5,6,7,8,9} शहर के नंबरों को दर्शाता है। DistanceFunction->(d[[#1,#2]]&) मैट्रिक्स d पास करता है, जो शहरों के बीच की दूरी को दर्शाता है।

आउटपुट

1

{137, {1, 2, 5, 9, 8, 7, 6, 3, 4}}

आउटपुट सबसे छोटी दूरी और उसके संबंधित मार्ग को दर्शाता है। सबसे छोटी दूरी 137 है, और मार्ग 1→2→5→9→8→7→6→3→4→1 है। ABC वर्णमाला क्रम में बदलने पर, यह A, B, E, I, H, G, F, C, D बन जाता है।

पसंदीदा गणितीय सूत्र

Wed, 05 Oct 2022 13:24:50 +0900

विल्सन की प्रमेय

जब $p$ एक अभाज्य संख्या है, तो $(p−1)!≡−1 \pmod p$ सत्य है।

यूलर का सूत्र

$e^{iπ}+1=0$

फ़र्मेट का अंतिम प्रमेय

$n≥3$ होने वाले पूर्णांक $n$ के लिए, $x^n+y^n=z^n$ को संतुष्ट करने वाले धनात्मक पूर्णांक $x,y,z$ मौजूद नहीं हैं।

बासेल समस्या

$1/1^2+1/2^2+1/3^2+1/4^2+...=π^2/6$

यूलर का अभाज्य-उत्पादक सूत्र

जब $n$, $0$ से $39$ तक का पूर्णांक होता है, तो $n^2+n+41$ हमेशा अभाज्य संख्या होता है।

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