رياضيات وتشفير وكم on kenji.blog

"تشريح كامل" فهم أقوى خوارزمية لتحليل التشفير "GNFS" عن طريق تنفيذها بلغة C++

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

“تشريح كامل” فهم أقوى خوارزمية لتحليل التشفير “GNFS” عن طريق تنفيذها بلغة C++

يدعم “تشفير RSA” أسس الإنترنت الحديث. يعتمد أمانه على الاعتقاد الرياضي بأنه “من المستحيل عمليا على أجهزة الكمبيوتر الحالية تحليل عدد مركب عملاق إلى عوامله الأولية”.

ومع ذلك، لم تستسلم البشرية أبدا. حاليا، يوجد ** أقوى وأحدث خوارزمية ** للبشرية لتحليل الأعداد الأولية الضخمة على أجهزة الكمبيوتر الكلاسيكية (أجهزة الكمبيوتر العادية، وليست الكمومية). تسمى هذه الخوارزمية ** “غربال حقل الأعداد العام (GNFS: General Number Field Sieve)” **.

في هذه المقالة، سننشر الكود المصدري بالكامل بلغة C++ (باستخدام أعداد صحيحة متعددة الدقة boost::multiprecision من مكتبة Boost) والذي يجسد بشكل دقيق منطق الحوسبة المتقدم لهذه الخوارزمية، وسنشرح بعمق “نظرية الأعداد الجبرية” التي تقف وراءها.

يرجى الاستمتاع بأسرار الرياضيات وقوة علوم الكمبيوتر التي تقهرها مع الكود المصدري.

1. إطار عمل GNFS المتقدم (الكود المصدري الكامل)

أولا، سنقدم الصورة الكاملة لتنفيذ GNFS بلغة C++ الذي سنشرحه هنا. نظام غربال حقل الأعداد الفعلي (مثل CADO-NFS) هو نظام موزع ضخم يحتوي على مئات الآلاف من أسطر التعليمات البرمجية. ومع ذلك، يقوم هذا الكود باستخراج ** “5 مسارات (مراحل) أساسية” ** تشكل GNFS، وتصميمها كفئات، ونمذجتها في تكوين أدنى دون فقدان معناها الرياضي.

 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 إطار عمل منطقي متقدم
//
// يصمم هذا الكود بشكل دقيق المراحل الخمسة لـ GNFS الحديث
// المستخدم في CADO-NFS وغيرها، كفئات C++ (Boost).
// ============================================================================

struct Relation {
 int64_t a;
 int64_t b;
 std::vector<uint32_t> rational_primes;
 std::vector<uint32_t> algebraic_primes;
};

// ============================================================================
// المرحلة 1: اختيار كثير الحدود (خوارزمية 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) {}

 // توليد كثير الحدود الأولي بناء على توسيع الأساس m (في الواقع يتم استخدام تقليص قاعدة الشبكة LLL الأكثر تقدما)
 void select(const cpp_int& N) {
 std::cout << "[المرحلة 1] اختيار كثير الحدود (الدرجة " << degree << ") يبدأ..." << std::endl;
 // توسيع أساس 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[المرحلة 1] اكتملت." << std::endl;
 }
};

// ============================================================================
// المرحلة 2: غربال الشبكة (Lattice Sieving)
// ============================================================================
// لا يستخدم GNFS الحديث Line Sieve، بل يستخدم
// Special-q Lattice Sieving الذي طوره Franke-Kleinjung كمعيار.
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 << "[المرحلة 2] توليد قواعد العوامل (الحد النسبي: " << rational_bound << "، الحد الجبري: " << algebraic_bound << ")" << std::endl;
 // (محذوف) في الواقع يتم توليد الأعداد الأولية والتصفية باستخدام رموز Legendre
 }

 std::vector<Relation> sieve(const PolynomialSelector& poly) {
 std::cout << "[المرحلة 2] Special-q Lattice Sieving نشط..." << std::endl;
 std::vector<Relation> relations;
 // تنفيذ وهمي: يقوم غربال الشبكة الفعلي بمسح مئات الجيجابايت من الذاكرة في كتل
 // يتم تعيين الأزواج (a, b) لشبكة (a = i*q + j*...) لكل عدد أولي خاص q،
 // ويتم تشغيل غربلة ترفع كفاءة ذاكرة التخزين المؤقت إلى أقصى حد.

 // إضافة علاقة وهمية واحدة للتوضيح
 Relation r; r.a = 17; r.b = 3;
 r.rational_primes = {2, 5};
 r.algebraic_primes = {3, 7};
 relations.push_back(r);

 std::cout << "[المرحلة 2] تم العثور على " << relations.size() << " علاقة." << std::endl;
 return relations;
 }
};

// ============================================================================
// المرحلة 3: التصفية (إزالة الفردية ودمج الزمرة)
// ============================================================================
class Filter {
public:
 void reduce_matrix(std::vector<Relation>& relations) {
 std::cout << "[المرحلة 3] تصفية العلاقات..." << std::endl;
 // 1. إزالة الفردية (إزالة العلاقات التي تحتوي على أعداد أولية تظهر مرة واحدة فقط)
 // 2. دمج الزمرة (دمج العلاقات لتحويل مصفوفة متفرقة إلى كثيفة)
 // في الواقع يتم ضغط مصفوفات بمئات الملايين من الصفوف إلى بضعة ملايين باستخدام خوارزميات مثل Union-Find.
 std::cout << "[المرحلة 3] تم تقليل حجم المصفوفة بشكل مثالي." << std::endl;
 }
};

// ============================================================================
// المرحلة 4: الجبر الخطي فوق 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 << "[المرحلة 4] خوارزمية Block Wiedemann فوق GF(2) تبدأ..." << std::endl;
 // التكرار على حسابات ضرب المصفوفة المتفرقة في المتجه،
 // والعثور على متجهات الحلول (نواة) بحيث M * x = 0 mod 2.

 std::vector<std::vector<int>> dependencies; // قائمة التبعيات
 // بيانات وهمية
 dependencies.push_back({0});

 std::cout << "[المرحلة 4] تم العثور على " << dependencies.size() << " تبعيات خطية (مربعات كاملة)." << std::endl;
 return dependencies;
 }
};

// ============================================================================
// المرحلة 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 << "[المرحلة 5] حساب الجذر التربيعي الجبري..." << std::endl;

 // 1. حساب الجذر التربيعي النسبي V
 cpp_int V = 1;
 // V = sqrt( prod(a - bm) ) mod N

 // 2. حساب الجذر التربيعي الجبري gamma (باستخدام طريقة Montgomery، إلخ)
 // العثور على العنصر gamma في الحقل الجبري الضخم O_K وتحويله إلى العالم الحقيقي باستخدام التماثل phi
 // Y = phi(gamma) mod N
 cpp_int Y = 1;

 // نفترض أنه تمت إضافة سلسلة من الرموز التربيعية (Quadratic Characters) في المرحلتين 2 و 4
 // لتجنب عقبات (Obstruction) مجموعة أصناف المثاليات ومجموعة الوحدات.

 std::cout << " -> تم تطبيق التماثل phi." << std::endl;
 std::cout << "[المرحلة 5] جار حساب القاسم المشترك الأكبر (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 << "[نجاح] تم العثور على عامل غير بديهي: " << factor << std::endl;
 std::cout << " العامل الآخر: " << N / factor << std::endl;
 std::cout << "================================================================" << std::endl;
 } else {
 std::cout << "[فشل] حل بديهي. جاري تجربة التبعية التالية..." << std::endl;
 }
 }
};

// ============================================================================
// مسار التنفيذ الرئيسي
// ============================================================================
int main() {
 std::cout << "================================================================" << std::endl;
 std::cout << " [SOTA GNFS] محرك General Number Field Sieve (Boost C++) " << std::endl;
 std::cout << "================================================================" << std::endl;

 // عدد مركب ضخم N نريد تحليله، مثل RSA-270
 cpp_int N("233108530344407544527637656910680524145619812480305449042948611968495918245135782867888369318577116418213919268572658314913060672626911354027609793166341626693946596196427744273886601876896313468704059066746903123910748277606548649151920812699309766587514735456594993207");

 // درجة كثير الحدود (عادة يتم اختيار درجة 5 إلى 6 للأرقام الأكبر من 130 رقما)
 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[النظام] اكتمل مسار SOTA GNFS في " << elapsed.count() << " ثانية." << std::endl;

 return 0;
}

إذن، كيف يقوم هذا الكود بتحطيم جدران التشفير؟ سنقوم بتقسيم وشرح الخوارزميات الدقيقة والرياضيات المتقدمة لكل من المراحل الخمس.

2. الهدف النهائي لـ GNFS: $X^2 \equiv Y^2 \pmod N$

ليس فقط GNFS، بل إن هدف معظم الخوارزميات الحديثة لتحليل الأعداد العملاقة هو العثور على زوج غير بديهي $(X, Y)$ يحقق المعادلة التطابقية التالية:

$$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$ (حل غير بديهي)، فهذا يعني أن هناك “قاسما مشتركا أكبر من 1 وأصغر من $N$” بين $(X-Y)$ و $N$. هنا، إذا استخدمنا خوارزمية إقليدس لحساب ** $\gcd(X-Y, N)$ **، فيمكننا بسهولة إيجاد العامل الأولي لـ $N$.

ومع ذلك، فإن العثور على $X$ و $Y$ يشبه البحث عن إبرة في الصحراء. لذلك، يتخذ GNFS نهجا عبقريا من خلال توزيع الحسابات عن طريق إنشاء ** عالمين **: “عالم الأعداد الصحيحة الحقيقية” و “عالم الحقول الجبرية لكثيرات الحدود”.

3. المرحلة 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) والتوسيع بأساس 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)$ بخصائص مهمة للغاية وهي ** “إذا عوضنا $m$ في المتغير $x$، فإن القيمة ستكون بالضبط $N$ ($f(m) = N$)” **. وبعبارة أخرى، $f(m) \equiv 0 \pmod N$. يتم تعريف كثير الحدود النسبي على أنه $g(x) = x - m$.

نتيجة لذلك، يتم ربط ** “عالم الحقل الجبري $\mathbb{Z}[\alpha]$” ** المحكوم بجذور $\alpha$ لـ $f(x)=0$ مع ** “عالم الأعداد النسبية (الصحيحة) $\mathbb{Z}$” ** المعتاد من خلال تماثل الحلقات $x \to m$.

في أنظمة مثل CADO-NFS، يتم استخدام خوارزمية KleinJung وخوارزمية تقليص قاعدة الشبكة LLL للبحث عن “أفضل كثير حدود $f(x)$” لا تكون معاملاته كبيرة جدا وتظهر فيه الأعداد الأولية بسهولة في الخطوات اللاحقة. يستغرق هذا البحث أشهرا.

4. المرحلة 2: غربلة الشبكة الخاصة (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،
 // وتشغيل غربال يحقق أقصى كفاءة لذاكرة التخزين المؤقت.
 // ...
 }
};

بعد إعداد العالمين، تتمثل الخطوة التالية في البحث عن “أعداد ملساء (أعداد تتكون فقط من عوامل أولية صغيرة)” في كلا العالمين. يتم توليد أزواج لا حصر لها من الأعداد الصحيحة $(a, b)$، ويتم حساب القيمتين التاليتين:

القيمة الجانبية النسبية : $a - bm$
المعيار الجانبي الجبري : $b^d f(a/b)$

يهدف GNFS إلى جمع عشرات إلى مئات الملايين من ** “الأزواج (العلاقات) التي يمكن تحليل قيمها الجانبية النسبية والجبرية بالكامل باستخدام عوامل أولية صغيرة فقط” **.

في السابق، تم استخدام “غربال الخط (Line Sieve)"، حيث يتم ترتيب أزواج $(a, b)$ على مستوى $xy$ وقسمتها على الأعداد الأولية. ومع ذلك، كان هذا بطيئا جدا لأنه يسبب فشلا كبيرا في ذاكرة التخزين المؤقت بسبب الوصول العشوائي للذاكرة.

لذلك، تستخدم الأكواد الحديثة طريقة تسمى ** “Special-q Lattice Sieve” **. يتم تثبيت عدد أولي كبير بما فيه الكفاية $q$، وتُحسب فقط أزواج $(a, b)$ حيث “القيمة الجبرية يجب أن تقبل القسمة على $q$”. تشكل الأزواج $(a, b)$ التي تلبي هذا الشرط “شبكة (Lattice)"، مما يجعل قفزة العنوان المحسوبة ثابتة وتتناسب تماما مع ذاكرة التخزين المؤقت L1/L2 لوحدة المعالجة المركزية. أدى هذا التحسين إلى زيادة سرعة حسابات GNFS بشكل هائل.

5. المرحلة 3: التصفية (Filtering)

1
2
3
4
5
6
7


class Filter {
public:
 void reduce_matrix(std::vector<Relation>& relations) {
 // 1. إزالة الفردية (إزالة العلاقات التي تحتوي على أعداد أولية تظهر مرة واحدة فقط)
 // 2. دمج الزمرة (دمج العلاقات لجعل المصفوفة المتفرقة كثيفة)
 }
};

مئات الملايين من العلاقات التي جمعتها أجهزة الكمبيوتر حول العالم على مدار عدة أشهر في المرحلة الثانية. ومع ذلك، إذا قمنا بإدخالها مباشرة إلى “خطوة حل نظام المعادلات (حساب المصفوفة)” التالية، فإن ذاكرة الحاسوب العملاق ستمتلئ.

لذلك، يتم إجراء عملية ضغط قصوى للمصفوفة تسمى ** التصفية (Filtering) **.

إزالة الفردية (Singleton removal) لنفترض أن عددا أوليا ضخما $p$ ظهر “مرة واحدة فقط” من بين مئات الملايين من العلاقات. هدفنا هو “جعل جميع أسس الأعداد الأولية زوجية (مضاعفات 2)"، لذلك فإن العدد الأولي الذي يظهر مرة واحدة لا يمكن أبدا أن يصبح زوجيا. وبالتالي، يتم حذف العلاقة التي تحتوي على هذا العدد الأولي على الفور كـ “قمامة غير مجدية”. وبسبب سلسلة الأحداث هذه، يتم تقليص مئات الملايين من صفوف البيانات.
دمج الزمرة (Clique merging) بعد ذلك، من خلال ضرب (جمع) العلاقات التي تشترك في أعداد أولية معينة، يتم ضغط (تكثيف) المصفوفة المتفرقة وتقليل عدد الصفوف (باستخدام تقنية مشابهة للبحث عن الزمرة في نظرية المخططات).

من خلال هذا التحسين، يتم ضغط المصفوفة المتفرقة الضخمة بشكل كبير إلى حجم يمكن حسابه.

6. المرحلة 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) {
 // حسابات ضرب المصفوفة المتفرقة في المتجه،
 // وإيجاد متجهات حلول بحيث M * x = 0 mod 2.
 }
};

الآن نصل إلى جوهر اللغز. نقوم بضرب العلاقات المجمعة للعثور على ** “التركيبة التي تصبح فيها كل قوى العوامل الأولية زوجية” **.

من الناحية الرياضية، باستخدام مصفوفة ضخمة $M$ تمثل عناصرها “الزوجي والفردي (أي 0 أو 1)” لقوى كل عدد أولي، والمتجه $x$ الذي يمثل العلاقة المستخدمة، فإننا نحل (البحث في الفضاء الفارغ): $M \cdot x \equiv 0 \pmod 2$

علينا حل نظام معادلات مصفوفة بملايين الصفوف وملايين الأعمدة. في الحذف الغاوسي العادي، سيكون التعقيد $O(N^3)$، مما يعني أن الحساب لن يكتمل حتى نهاية الكون.

لذلك، تعتمد التطبيقات الحديثة ** “طريقة Block Wiedemann” **. هذه طريقة فضاء جزئي لـ Krylov تعثر على الحل عبر تكرار عمليات ضرب المصفوفات والمتجهات، مستغلة حقيقة أن المصفوفة $M$ “متفرقة جدا (معظمها 0)”. على عكس طريقة Block Lanczos القديمة، تقوم Block Wiedemann بتقسيم عملية الحساب تماما على مجموعات منفصلة، وتظهر قوة هائلة في الحوسبة السحابية الموزعة الحديثة والحواسيب العملاقة.

7. المرحلة 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)
 }
};

من خلال حسابات المصفوفة في المرحلة 4، حصلنا على مجموعة من العلاقات $S$ والتي “إذا تم ضربها معا، ستصبح كل أسس العوامل الأولية زوجية”. يتيح لنا ذلك بناء “مربعات” في كل من العوالم النسبية والجبرية.

نظرا لأن الجانب النسبي هو مجرد ضرب لأعداد صحيحة، فمن السهل حساب الجذر التربيعي $V$.

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

لكن الجحيم الحقيقي يكمن في “الجانب الجبري”. في عالم الحقل الجبري $\mathbb{Z}[\alpha]$، لا يتم الحفاظ على تفرد التحليل إلى العوامل الأولية، لذلك أجرينا الحسابات باستخدام المثاليات. تضمن حسابات المصفوفة فقط أن النتيجة ** “مربع مثالي”، لكنها لا “تضمن أنها مربع لعنصر ($\gamma^2$)” **.

هنا يظهر عائق هائل في نظرية الأعداد الجبرية، والذي يسمى “عائق مجموعة أصناف المثاليات” و “عائق مجموعة الوحدات”. يخترق GNFS هذا الجدار باستخدام سحر يسمى ** “الرموز التربيعية (Quadratic Characters)” **. في مصفوفة المرحلة 4، تتم إضافة عدد قليل من أعمدة البقايا التربيعية (رمز Legendre) سراً لمثاليات أولية خاصة. بفضل ذلك، تتجاوز المجموعة المكتشفة $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 ليست مجرد تقنية برمجة. إنها تحفة من ذكاء البشرية تغلبت على “أعماق الرياضيات البحتة” مثل الجبر المجرد، ونظرية الحلقات، ومجموعة أصناف المثاليات، وذلك باستخدام “هندسة متطرفة” مثل البنية الموزعة للحواسيب العملاقة وتحسين ذاكرة التخزين المؤقت.

يتم حماية معلومات الدردشات والبطاقات الائتمانية التي نرسلها كل يوم بواسطة هذه المعارك الرياضية الهائلة.

نأمل من خلال إطار عمل C++ هذا، أن تتمكن من الشعور بـ “رومانسية الرياضيات والكمبيوتر” الكامنة وراء خوارزميات كسر التشفير المتطورة.

اقتباسات ألبرت أينشتاين

Sat, 24 Aug 2024 18:38:47 +0900

مرحباً!

اليوم، أود أن أتحدث عن اقتباسات ألبرت أينشتاين.

العالم لا يقدر أفعالك الصالحة؟

1
2
3
4
5
6


العالم لن يقدر أبداً مليون فعل صالح تقوم به.
لكنه سينتقدك على شيء واحد خاطئ تفعله...
لكن، لا تفقد الأمل
"ارتفع دائماً فوق كل الضحك والانتقاد. ابق قوياً."

- ألبرت أينشتاين

هذه الكلمات يُقال إن أينشتاين قد نطق بها. إنها تشير بحدة إلى قسوة المجتمع التي نشعر بها كل يوم والتحيز في تقييمات الناس.

ومع ذلك، استمر في النهوض

“ارتفع دائماً فوق كل الضحك والانتقاد. ابق قوياً.”

هذا الجزء التالي من الاقتباس يمكن اعتباره إجابة أينشتاين على الواقع القاسي المذكور أعلاه. إنه يعلمنا أهمية عدم الاستسلام للانتقاد أو السخرية، والاستمرار في المضي قدماً مع الإيمان بأنفسنا.

تطبيق تعاليم أينشتاين في الحياة اليومية

هذا الاقتباس متصل بعمق بحياتنا اليومية. على سبيل المثال، قد لا يتم الاعتراف بجهودك في العمل، وتبرز الأخطاء الصغيرة فقط. أو ربما يتم اقتطاع جزء من تصريح لك على وسائل التواصل الاجتماعي وانتقاده.

في مثل هذه الأوقات، يرجى تذكر كلمات أينشتاين هذه. من المهم أن تحافظ على معتقداتك الخاصة بدلاً من التأثر بتقييمات الآخرين.

الخاتمة

يعلمنا اقتباس أينشتاين هذا أهمية “العيش مع الإيمان بأنفسنا دون أن نتأثر بتقييمات الآخرين”. دعونا نتحلى بالشجاعة لاتباع الطريق الذي نؤمن به دون الاستسلام للانتقاد أو السخرية.

أخيراً، كلمات أينشتاين مرة أخرى.

** “ارتفع دائماً فوق كل الضحك والانتقاد. ابق قوياً.” **

نأمل أن يتردد صدى هذه الكلمات في قلبك وتلهمك لاتخاذ خطوة إيجابية إلى الأمام.

مشاكل رياضية غير محلولة

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