التحقق العددي من فرضية ABC (نعم ، هذا واحد)

مرحباً هابر.

كانت هناك بالفعل العديد من المقالات حول فرضية ABC في Geektimes Habr (على سبيل المثال ، في 2013 و 2018 ). القصة نفسها عن نظرية لا يمكن إثباتها في البداية لسنوات عديدة ، ثم لا يمكن التحقق منها لنفس عدد السنوات ، تستحق بالتأكيد فيلمًا روائيًا على الأقل. ولكن في ظل هذه القصة الرائعة ، تعتبر النظرية نفسها سطحية للغاية ، على الرغم من أنها ليست أقل إثارة للاهتمام. بالفعل على الأقل من خلال حقيقة أن فرضية ABC هي واحدة من المشكلات القليلة التي لم يتم حلها في العلوم الحديثة ، وبيان المشكلة الذي يمكن حتى الصف الخامس فهمه. إذا كانت هذه الفرضية صحيحة حقًا ، فعندئذٍ يمكن أن تتبع بسهولة من إثبات نظريات مهمة أخرى ، على سبيل المثال ، إثبات نظرية فيرمات .

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

من يهتم بما حدث ، من فضلك ، تحت القطة.

بيان المشكلة


لنبدأ من البداية. ما هي النظرية؟ كما تقول ويكيبيديا (الصياغة في النسخة الإنجليزية أكثر وضوحًا قليلاً) ، للأرقام البسيطة المتبادلة (التي لا تحتوي على قواسم مشتركة) أ ، ب و ج بحيث أن أ + ب = ج ، لأي ε> 0 هناك عدد محدود من ثلاث مرات أ + ب = c ، بحيث:



تسمى دالة rad الراديكالية ، وتشير إلى نتاج العوامل الأولية لرقم. على سبيل المثال ، rad (16) = rad (2 * 2 * 2 * 2) = 2 ، rad (17) = 17 (17 هو رئيس) ، rad (18) = rad (2 * 3 * 3) = 2 * 3 = 6 ، راد (1،000،000) = راد (2 ^ 6 ⋅ 5 ^ 6) = 2 * 5 = 10.

في الواقع ، جوهر النظرية هو أن عدد هذه الثلاثيات صغير جدًا. على سبيل المثال ، إذا أخذنا عشوائيًا ε = 0.2 والمساواة 100 + 27 = 127: rad (100) = rad (2 * 2 * 5 * 5) = 10 ، rad (27) = rad (3 * 3 * 3) = 3 ، rad (127) = 127، rad (a * b * c) = rad (a) * rad (b) * rad (c) = 3810، 3810 ^ 1.2 أكبر بشكل واضح من 127 ، عدم المساواة لا تصمد. ولكن هناك استثناءات ، على سبيل المثال ، للمساواة 49 + 576 = 625 ، يتم تحقيق شرط النظرية (أولئك الذين يرغبون في التحقق من تلقاء أنفسهم).

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

لذلك دعونا نبدأ.

كود المصدر


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

الحصول على الجذر : نحن نحلل الرقم إلى عوامل أولية ، ثم نزيل التكرارات ، ونحول الصفيف إلى مجموعة. ثم مجرد الحصول على منتج لجميع العناصر.

def prime_factors(n): factors = [] # Print the number of two's that divide n while n % 2 == 0: factors.append(int(2)) n = n / 2 # n must be odd at this point so a skip of 2 ( i = i + 2) can be used for i in range(3, int(math.sqrt(n)) + 1, 2): # while i divides n , print i ad divide n while n % i == 0: factors.append(int(i)) n = n / i # Condition if n is a prime number greater than 2 if n > 2: factors.append(int(n)) return set(factors) def rad(n): result = 1 for num in prime_factors(n): result *= num return result 

الأعداد الأولية المتبادلة : احسب الأرقام ، وتحقق فقط من تقاطع المجموعات.

 def not_mutual_primes(a,b,c): fa, fb, fc = prime_factors(a), prime_factors(b), prime_factors(c) return len(fa.intersection(fb)) == 0 and len(fa.intersection(fc)) == 0 and len(fb.intersection(fc)) == 0 

تحقق : نستخدم وظائف تم إنشاؤها بالفعل ، كل شيء بسيط هنا.

 def check(a,b,c): S = 1.2 # Eps=0.2 if c > (rad(a)*rad(b)*rad(c))**S and not_mutual_primes(a, b, c): print("{} + {} = {} - PASSED".format(a, b, c)) else: print("{} + {} = {} - FAILED".format(a, b, c)) check(10, 17, 27) check(49, 576, 625) 

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

تمت إعادة كتابة النسخة النهائية في C ++ باستخدام تعدد مؤشرات الترابط وبعض التحسين (العمل في C مع مجموعات متقاطعة سيكون شديد الصعوبة ، على الرغم من أنه ربما أسرع). كود المصدر تحت المفسد ، يمكن تجميعه في مترجم g ++ المجاني ، يعمل الرمز تحت Windows و OSX وحتى على Raspberry Pi.

كود C ++
 // To compile: g++ abc.cpp -O3 -fopenmp -oabc #include <string.h> #include <math.h> #include <stdbool.h> #include <stdint.h> #include <stdio.h> #include <vector> #include <set> #include <map> #include <algorithm> #include <time.h> typedef unsigned long int valType; typedef std::vector<valType> valList; typedef std::set<valType> valSet; typedef valList::iterator valListIterator; std::vector<valList> valFactors; std::vector<double> valRads; valList factors(valType n) { valList results; valType z = 2; while (z * z <= n) { if (n % z == 0) { results.push_back(z); n /= z; } else { z++; } } if (n > 1) { results.push_back(n); } return results; } valList unique_factors(valType n) { valList results = factors(n); valSet vs(results.begin(), results.end()); valList unique(vs.begin(), vs.end()); std::sort(unique.begin(), unique.end()); return unique; } double rad(valType n) { valList f = valFactors[n]; double result = 1; for (valListIterator it=f.begin(); it<f.end(); it++) { result *= *it; } return result; } bool not_mutual_primes(valType a, valType b, valType c) { valList res1 = valFactors[a], res2 = valFactors[b], res3; // = valFactors[c]; valList c12, c13, c23; set_intersection(res1.begin(),res1.end(), res2.begin(),res2.end(), back_inserter(c12)); if (c12.size() != 0) return false; res3 = valFactors[c]; set_intersection(res1.begin(),res1.end(), res3.begin(),res3.end(), back_inserter(c13)); if (c13.size() != 0) return false; set_intersection(res2.begin(),res2.end(), res3.begin(),res3.end(), back_inserter(c23)); return c23.size() == 0; } int main() { time_t start_t, end_t; time(&start_t); int cnt=0; double S = 1.2; valType N_MAX = 10000000; printf("Getting prime factors...\n"); valFactors.resize(2*N_MAX+2); valRads.resize(2*N_MAX+2); for(valType val=1; val<=2*N_MAX+1; val++) { valFactors[val] = unique_factors(val); valRads[val] = rad(val); } time(&end_t); printf("Done, T = %.2fs\n", difftime(end_t, start_t)); printf("Calculating...\n"); #pragma omp parallel for reduction(+:cnt) for(int a=1; a<=N_MAX; a++) { for(int b=a; b<=N_MAX; b++) { int c = a+b; if (c > pow(valRads[a]*valRads[b]*valRads[c], S) && not_mutual_primes(a,b,c)) { printf("%d + %d = %d\n", a,b,c); cnt += 1; } } } printf("Done, cnt=%d\n", cnt); time(&end_t); float diff_t = difftime(end_t, start_t); printf("N=%lld, T = %.2fs\n", N_MAX, diff_t); } 


بالنسبة لأولئك الذين هم كسالى للغاية لتثبيت مترجم C ++ ، يتم توفير إصدار Python محسن قليلاً ، والذي يمكن إطلاقه في أي محرر عبر الإنترنت (استخدمت https://repl.it/languages/python ).

نسخة بايثون
 from __future__ import print_function import math import time import multiprocessing prime_factors_list = [] rad_list = [] def prime_factors(n): factors = [] # Print the number of two's that divide n while n % 2 == 0: factors.append(int(2)) n = n / 2 # n must be odd at this point so a skip of 2 ( i = i + 2) can be used for i in range(3, int(math.sqrt(n)) + 1, 2): # while i divides n , print i ad divide n while n % i == 0: factors.append(int(i)) n = n / i # Condition if n is a prime number greater than 2 if n > 2: factors.append(int(n)) return factors def rad(n): result = 1 for num in prime_factors_list[n]: result *= num return result def not_mutual_primes(a,b,c): fa, fb, fc = prime_factors_list[a], prime_factors_list[b], prime_factors_list[c] return len(fa.intersection(fb)) == 0 and len(fa.intersection(fc)) == 0 and len(fb.intersection(fc)) == 0 def calculate(N): S = 1.2 cnt = 0 for a in range(1, N): for b in range(a, N): c = a+b if c > (rad_list[a]*rad_list[b]*rad_list[c])**S and not_mutual_primes(a, b, c): print("{} + {} = {}".format(a, b, c)) cnt += 1 print("N: {}, CNT: {}".format(N, cnt)) return cnt if __name__ == '__main__': t1 = time.time() NMAX = 100000 prime_factors_list = [0]*(2*NMAX+2) rad_list = [0]*(2*NMAX+2) for p in range(1, 2*NMAX+2): prime_factors_list[p] = set(prime_factors(p)) rad_list[p] = rad(p) calculate(NMAX) print("Done", time.time() - t1) 


النتائج


الثلاث مرات ، أ ، ب ، ج قليلة جدًا حقًا.

يتم إعطاء بعض النتائج أدناه:
N = 10 : 1 "ثلاثة" ، مهلة <0.001c
1 + 8 = 9

N = 100 : 2 "ثلاث مرات" ، وقت التشغيل <0.001c
1 + 8 = 9
1 + 80 = 81

N = 1000 : 8 "ثلاث مرات" ، وقت التشغيل <0.01c
1 + 8 = 9
1 + 80 = 81
1 + 242 = 243
1 + 288 = 289
1 + 512 = 513
3 + 125 = 128
13 + 243 = 256
49 + 576 = 625

N = 10000 : 23 "ثلاث مرات" ، وقت التشغيل 2 ثانية

Threes A، B، C حتى 10000
1 + 8 = 9
1 + 80 = 81
1 + 242 = 243
1 + 288 = 289
1 + 512 = 513
1 + 2400 = 2401
1 + 4374 = 4375
1 + 5831 = 5832
1 + 6560 = 6561
1 + 6655 = 6656
1 + 6859 = 6860
3 + 125 = 128
5 + 1024 = 1029
10 + 2187 = 2197
11 + 3125 = 3136
13 + 243 = 256
49 + 576 = 625
1331 + 9604 = 10935
81 + 1250 = 1331
125 + 2187 = 2312
243 + 1805 = 2048
289 + 6272 = 6561
625 + 2048 = 2673

N = 100000 : 53 ثلاث مرات ، وقت التشغيل 50 ج

Threes A، B، C حتى 100،000
1 + 8 = 9
1 + 80 = 81
1 + 242 = 243
1 + 288 = 289
1 + 512 = 513
1 + 2400 = 2401
1 + 4374 = 4375
1 + 5831 = 5832
1 + 6560 = 6561
1 + 6655 = 6656
1 + 6859 = 6860
1 + 12167 = 12168
1 + 14336 = 14337
1 + 57121 = 57122
1 + 59048 = 59049
1 + 71874 = 71875
3 + 125 = 128
3 + 65533 = 65536
5 + 1024 = 1029
7 + 32761 = 32768
9 + 15616 = 15625
9 + 64000 = 64009
10 + 2187 = 2197
11 + 3125 = 3136
13 + 243 = 256
28 + 50625 = 50653
31 + 19652 = 19683
37 + 32768 = 32805
49 + 576 = 625
49 + 16335 = 16384
73 + 15552 = 15625
81 + 1250 = 1331
121 + 12167 = 12288
125 + 2187 = 2312
125 + 50176 = 50301
128 + 59049 = 59177
169 + 58880 = 59049
243 + 1805 = 2048
243 + 21632 = 21875
289 + 6272 = 6561
343 + 59049 = 59392
423 + 16384 = 16807
507 + 32768 = 33275
625 + 2048 = 2673
1331 + 9604 = 10935
1625 + 16807 = 18432
28561 + 89088 = 117649
28561 + 98415 = 126976
3584 + 14641 = 18225
6561 + 22000 = 28561
7168 + 78125 = 85293
8192 + 75843 = 84035
36864 + 41261 = 78125

مع N = 1،000،000 ، لدينا 102 "ثلاث مرات" فقط ، يتم إعطاء قائمة كاملة تحت المفسد.

Threes A، B، C حتى 1،000،000
1 + 8 = 9
1 + 80 = 81
1 + 242 = 243
1 + 288 = 289
1 + 512 = 513
1 + 2400 = 2401
1 + 4374 = 4375
1 + 5831 = 5832
1 + 6560 = 6561
1 + 6655 = 6656
1 + 6859 = 6860
1 + 12167 = 12168
1 + 14336 = 14337
1 + 57121 = 57122
1 + 59048 = 59049
1 + 71874 = 71875
1 + 137780 = 137781
1 + 156249 = 156250
1 + 229375 = 229376
1 + 263168 = 263169
1 + 499999 = 500000
1 + 512000 = 512001
1 + 688127 = 688128
3 + 125 = 128
3 + 65533 = 65536
5 + 1024 = 1029
5 + 177147 = 177152
7 + 32761 = 32768
9 + 15616 = 15625
9 + 64000 = 64009
10 + 2187 = 2197
11 + 3125 = 3136
13 + 243 = 256
13 + 421875 = 421888
17 + 140608 = 140625
25 + 294912 = 294937
28 + 50625 = 50653
31 + 19652 = 19683
37 + 32768 = 32805
43 + 492032 = 492075
47 + 250000 = 250047
49 + 576 = 625
49 + 16335 = 16384
49 + 531392 = 531441
64 + 190269 = 190333
73 + 15552 = 15625
81 + 1250 = 1331
81 + 123823 = 123904
81 + 134375 = 134456
95 + 279841 = 279936
121 + 12167 = 12288
121 + 255879 = 256000
125 + 2187 = 2312
125 + 50176 = 50301
128 + 59049 = 59177
128 + 109375 = 109503
128 + 483025 = 483153
169 + 58880 = 59049
243 + 1805 = 2048
243 + 21632 = 21875
289 + 6272 = 6561
338 + 390625 = 390963
343 + 59049 = 59392
423 + 16384 = 16807
507 + 32768 = 33275
625 + 2048 = 2673
864 + 923521 = 924385
1025 + 262144 = 263169
1331 + 9604 = 10935
1375 + 279841 = 281216
1625 + 16807 = 18432
2197 + 583443 = 585640
2197 + 700928 = 703125
3481 + 262144 = 265625
3584 + 14641 = 18225
5103 + 130321 = 135424
6125 + 334611 = 340736
6561 + 22000 = 28561
7153 + 524288 = 531441
7168 + 78125 = 85293
8192 + 75843 = 84035
8192 + 634933 = 643125
9583 + 524288 = 533871
10816 + 520625 = 531441
12005 + 161051 = 173056
12672 + 117649 = 130321
15625 + 701784 = 717409
18225 + 112847 = 131072
19683 + 228125 = 247808
24389 + 393216 = 417605
28561 + 89088 = 117649
28561 + 98415 = 126976
28561 + 702464 = 731025
32768 + 859375 = 892143
296875 + 371293 = 668168
36864 + 41261 = 78125
38307 + 371293 = 409600
303264 + 390625 = 693889
62192 + 823543 = 885735
71875 + 190269 = 262144
131072 + 221875 = 352947
132651 + 588245 = 720896


للأسف ، لا يزال البرنامج يعمل ببطء ، ولم أنتظر نتائج N = 10000000 ، ووقت الحساب أكثر من ساعة (ربما أخطأت في تحسين الخوارزمية في مكان ما ، ويمكنني القيام بعمل أفضل).

والأكثر إثارة للاهتمام هو النظر إلى النتائج بيانياً:



من حيث المبدأ ، من الواضح تمامًا أن اعتماد عدد الثلاثيات المحتملة على N ينمو بشكل أبطأ بشكل ملحوظ من N نفسه ، ومن المحتمل أن تتقارب النتيجة إلى عدد معين لكل ε. بالمناسبة ، مع زيادة ε ، ينخفض ​​عدد "الثلاثيات" بشكل ملحوظ ، على سبيل المثال ، بالنسبة لـ ε = 0.4 ، لدينا فقط متساوين لـ N <100000 (1 + 4374 = 4375 و 343 + 59049 = 59392). لذلك بشكل عام ، يبدو أن النظرية صحيحة حقًا (حسنًا ، وربما تم اختبارها بالفعل على أجهزة كمبيوتر أكثر قوة ، وربما تم حساب كل هذا منذ فترة طويلة).

يمكن لأولئك الذين يرغبون في التجربة بمفردهم ، إذا كان أي شخص لديه نتائج للأرقام 10،000،000 وأعلى ، فسأكون سعيدًا بإضافتها إلى المقالة. بالطبع ، سيكون من المثير للاهتمام "العد" حتى اللحظة التي تتوقف فيها مجموعة "الثلاثيات" تمامًا عن النمو ، ولكن يمكن أن تستغرق وقتًا طويلاً حقًا ، ويبدو أن سرعة الحساب تعتمد على N كـ N * N (أو ربما N ^ 3) ، والعملية طويل جدا. ومع ذلك ، هناك شيء رائع قريب ، وقد يرغب أولئك الذين يرغبون في الانضمام إلى البحث.

تحرير: كما هو مقترح في التعليقات ، فإن ويكيبيديا لديها بالفعل جدول بالنتائج - في النطاق N حتى 10 ^ 18 لا يزال عدد "الثلاثيات" في ازدياد ، لذلك لم يتم العثور على "نهاية" المجموعة حتى الآن. الأكثر إثارة للاهتمام - دسيسة لا تزال قائمة.

Source: https://habr.com/ru/post/ar427091/


All Articles