🏻 🚩 🥡 तनेज़ी का कार्य: गणित के विकास में एक नया चरण? 😖 👨🏾‍💻 🏰

परिचय

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

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

चुनौती इंदर तनेज़ी

सामान्य जानकारी

इंदर तानेगा एक ब्राज़ीलियाई लोकप्रिय गणितज्ञ हैं, जिन्होंने अपने जीवन का अधिकांश समय जादू वर्गों, त्रिकोणीय संख्याओं और अन्य मनोरंजक कार्यों के लिए समर्पित किया है। उन्होंने सदी की अनसुलझे समस्याओं को कभी नहीं उठाया, प्राकृतिक श्रृंखला के गुणों के अध्ययन में एक पेशेवर योगदान नहीं दिया, लेकिन यह उनके शौकिया अध्ययनों में था कि सवाल उठाए गए थे कि आधुनिक गणित जवाब नहीं दे सकता है।

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

संख्याओं के जोड़, घटाव, गुणा और एक शक्ति को बढ़ाने के लिए, सात डीज़ों का उपयोग करके 1958 की संख्या की कल्पना करें

उत्तर होगा:

$1958 = 22^2*2*2+22$

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

$1958 = ((12*((34*5)-6)+7)-8)-9$

अनुमेय संचालन के बीच शुरू में थे:

संघात: २ || ३ = २३ ||
जोड़: 2 + 3 = 5
घटाव: 2-3 = -1
गुणन: 2 * 3 = 6
एकात्मक ऋण: - (2 + 3) = - 5

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

एक साल बाद, स्वैच्छिक कार्य आरोही और अवरोही क्रम में संख्याओं का उपयोग करते हुए 1 से 11 111 तक संख्याओं के प्रतिनिधित्व की तालिका के साथ सामने आया। ऊपर बताए गए संचालन का सेट घटते क्रम में अंकों की सभी संख्याओं का प्रतिनिधित्व करने के लिए पर्याप्त है, साथ ही आरोही क्रम में सूची से 11 110 संख्याओं का प्रतिनिधित्व करने के लिए पर्याप्त है।

अनुमोदन की तलाश में, इंदर पेशेवर गणितज्ञों और लोकप्रिय ब्लॉगर्स के लिए व्यक्तिगत टिप्पणियों के साथ अपने काम को मेल करते हैं। अन्य प्राप्तकर्ताओं में मैट पार्कर - ऑस्ट्रेलियाई परियोजना "गणितीय स्टैंड-अप" का चेहरा और YouTube प्रोजेक्ट "नंबरफाइल" में से एक प्रतिभागी है। विशेष नंबर 10958 के बारे में वीडियो (Tanezh के अपघटन की तालिका में एकमात्र स्थान) को हल करने के प्रयासों के लिए पर्याप्त लोकप्रिय हो गया और Tanezh के बारे में लोकप्रिय विज्ञान लेख कभी-कभी पूरी दुनिया में दिखाई देते हैं।

मैड एस्ट्रोनॉमर और यांडेक्स.ज़ेन के एक अज्ञात लेखक ने इस कार्य को रूस में लाया। बाद में 10958 नंबर के लिए समाधान खोजने के लिए $ 5,000 के पुरस्कार के बारे में समाचार जोड़ा गया। हालांकि, न तो तेनझ, न ही पार्कर, और न ही एमआईटी कर्मचारियों को सार्वजनिक पुरस्कार के बारे में कुछ भी पता है। तीन वर्षों में, केवल दो शौकिया काम सामने आए, जिससे समाधान खोजने के लिए कम से कम कुछ प्रयास किए गए। पहले एक को TedX परियोजना के एक पूर्व-प्रतिभागी द्वारा प्रकाशित किया गया था और टेनज़ नियमों और संपूर्ण एल्गोरिथ्म के क्रम के अनुसार निर्मित कम्प्यूटेशनल अभिव्यक्तियों की कुल संख्या का मूल्यांकन करने के प्रश्न पर चिंता करता है। दूसरे का उद्देश्य कार्य के "कमजोर विस्तार" से है, जिसका नाम है:

आरोही क्रम में संख्याओं का उपयोग करते हुए 1 से 11 111 111 तक सभी संख्याओं का प्रतिनिधित्व करते हैं (एक अंक का उपयोग एक बार किया जा सकता है और प्रत्येक अंक का उपयोग किया जाना चाहिए), ऑपरेटरों की व्यवस्था: बाइनरी: इसके अलावा, घटाव, गुणन, विभाजन, घातांक; b) unary: unary minus, factorial, square root

अध्ययन के लेखक के अनुसार, यह कमजोर पड़ने, 11 111 105 संख्याओं का प्रतिनिधित्व करने के लिए पर्याप्त था। मूल वीडियो रिपोर्ट:

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

सटीक शब्दांकन और पहले सामान्यीकरण

लेखक की समस्या के मुक्त सूत्रीकरण ने हालत की गलत व्याख्या के आधार पर कई गलत निर्णयों को जन्म दिया। सबसे आम गलतियाँ:

"बाहरी" संघनन का उपयोग: प्रारंभिक वेक्टर के अंकों से नए ऑपरेटरों का संकलन अनुमेय है, लेकिन सामान्य रूप में दूसरे नंबर के दाईं ओर एक नंबर को जोड़ने के रूप में संघनन निषिद्ध है। उदाहरण: $2||3=23$ - कर सकते हैं, $(1+2)||3=33$ - यह असंभव है
गोलाई: पूर्णांकों में तनेझी समस्या को हल करने का मतलब न केवल पूर्णांक प्रारंभिक वेक्टर का उपयोग करना है, बल्कि आउटपुट पर पूर्णांक परिणाम प्राप्त करना है। उदाहरण: $8=(1-2+3)*4$ - कर सकते हैं, $7 \approx (1+2/3)*4=20/3$ - यह असंभव है
अतिरिक्त ऑपरेंड का उपयोग: किसी पावर को बढ़ाने के लिए ऑपरेशन करते समय, कुछ लेखक संख्या के प्रारंभिक सेट को डिग्री के लिए वैध आधार मानते हैं और मनमाना संकेतक का सहारा लेते हैं। उदाहरण: $31=(1+2^3)*4-5$ - कर सकते हैं, $10958 = (1+2^3)*3+4^3+5*6*7+8^4+9^4$ - यह असंभव है

हम एक निश्चित संख्या के लिए तनेझी समस्या के सत्यापन और निर्णय लेने की प्रक्रिया का वर्णन करते हैं। जटिल (सामान्य मामले में) संख्या के कुछ वेक्टर के लिए दें

$(c_1, c_2, ..., c_k)$ तीन प्रस्तावित

$(op, ind,ind+1)$ कहाँ पे

$ind$ तथा

$ind+1$ - लगातार प्राकृतिक संख्या,

$ind_1<=k$ ;

$op$ - ऑपरेटर कोड - 1 से 7 तक एक प्राकृतिक संख्या, फिर पुनरावृत्ति

$(op, ind,ind+1)$ वेक्टर पर

$(c_1, c_2, ..., c_k)$ हम उस प्रक्रिया को कहेंगे जिसका परिणाम लंबाई का वेक्टर है

$k-1$ , अर्थात्:

वेक्टर $(c_1, c_2, ... , _{ind-1}, c_{ind}||c_{ind+1}, c_{ind+2}, ... , c_k)$ के लिये $op=1$
वेक्टर $(c_1, c_2, ... , _{ind-1}, c_{ind}+c_{ind+1}, c_{ind+2}, ... , c_k)$ के लिये $op=2$
वेक्टर $(c_1, c_2, ... , _{ind-1}, |c_{ind}-c_{ind+1}|, c_{ind+2}, ... , c_k)$ के लिये $op=3$
वेक्टर $(c_1, c_2, ... , _{ind-1}, c_{ind}*c_{ind+1}, c_{ind+2}, ... , c_k)$ के लिये $op=4$
वेक्टर $(c_1, c_2, ... , _{ind-1}, c_{ind}/c_{ind+1}, c_{ind+2}, ... , c_k)$ के लिये $op=5$
वेक्टर $(c_1, c_2, ... , _{ind-1}, c_{ind}^{c_{ind+1}}, c_{ind+2}, ... , c_k)$ के लिये $op=6$
वेक्टर $(c_1, c_2, ... , _{ind-1}, c_{ind}^{-(c_{ind+1})}, c_{ind+2}, ... , c_k)$ के लिये $op=7$

प्रारंभिक वेक्टर दिए जाने चाहिए

$(1, 2, ... , 9)$ नौ तत्वों के बराबर उनके सीरियल नंबर। फिर वे कहते हैं कि कुछ पूर्णांक के लिए

$a$ यदि कोई अनुक्रम है (जिसे हम संख्या के लिए व्युत्पत्ति कहेंगे) a:

$(op_1, ind_1,{ind_1}+1)$ प्रारंभिक वेक्टर पर एक पुनरावृत्ति है, जिसका परिणाम वेक्टर (1) है

$(op_2, ind_2,{ind_2}+1)$ वेक्टर (1) पर एक पुनरावृत्ति है, जिसका परिणाम वेक्टर (2) है
...

$(op_8, ind_8,{ind_8}+1)$ वेक्टर (7) पर एक पुनरावृत्ति है, जिसका परिणाम वेक्टर (8) है,

जैसे कि वेक्टर (8) वेक्टर के बराबर है

$(a)$ या तो वेक्टर

$(-a)$ और एकता के बराबर ऑपरेटर के मूल्य के साथ प्रत्येक पुनरावृत्ति के लिए, यह सच है कि संख्या के साथ तत्व

$ind_m {ind_m}+1$ परिवर्तित नहीं हैं। कुछ पुनरावृत्ति करते समय, हम कुछ नए वेक्टर (x) परमाणु का एक तत्व कहेंगे, यदि इस तत्व का मान मूल वेक्टर से लिया गया हो या परमाणु मानों को मिला कर प्राप्त किया गया हो। हम कुछ नए वेक्टर (y) के एक तत्व को रूपांतरित कहेंगे यदि यह 6 बाइनरी अंकगणितीय संक्रियाओं में से एक के साथ 2 से 7 तक की संख्या के प्रदर्शन का परिणाम है, तो इससे पहले होने वाले पुनरावृत्तियों में।

प्रत्येक वेक्टर के लिए, संचालन की संख्या और मूल्यों के जोड़े को चुनने की संभावना

$(ind, ind+1)$ सीमित, परिणाम की प्राप्ति से पहले पुनरावृत्तियों की संख्या - संख्या a - भी सीमित है। नतीजतन, पूर्णांकों की एक सीमित संख्या होती है जिसके लिए आरोही क्रम में तनेझी समस्या का समाधान होता है। उदाहरणों द्वारा यह दिखाना भी संभव है कि पुनरावृत्तियों के विभिन्न अनुक्रम हमेशा अलग-अलग परिणाम नहीं देते हैं, और यह भी कि ऐसे सभी अनुक्रमों में पूरे या कम से कम वास्तविक परिणाम नहीं होते हैं। इसके अलावा, आँकड़े, विशेष रूप से, बिल एम्स के काम के परिणाम बताते हैं कि विभिन्न आउटपुट तर्कसंगत मूल्यों की संख्या अलग-अलग पूर्णांक मानों की संख्या से दोगुनी से अधिक नहीं हो सकती है। इसलिए, तनेझी समस्या का पहला महत्वपूर्ण सामान्यीकरण निम्नलिखित प्रश्नों का समूह है:

पूर्णांक परिणाम के कितने भिन्न निष्कर्ष मौजूद हैं?
कितने modulo पूर्णांक आउटपुट हैं?
कितने अलग-अलग जटिल मूल्य प्रदर्शित किए जाते हैं?
क्या यह सच है कि अलग-अलग तर्कसंगत मानों की संख्या घट गई है और मोडुलो कुछ पूर्णांक से अधिक नहीं है, अलग-अलग कटौती किए गए पूर्णांकों की संख्या के दुगुने से अधिक नहीं है? किस के लिए? क्या यह सामान्य रूप से सही है?

यह भी सच है कि जब एक पूर्णांक मान प्राप्त होता है, जैसे कि कुछ मध्यवर्ती पुनरावृत्तियों में, वेक्टर में अपरिमेय और जटिल मान होते हैं, विभिन्न कुल मूल्यों को प्राप्त करने की संभावना कम हो जाती है, क्योंकि कई ऑपरेशन (तर्कसंगत में तर्क को जोड़कर, तर्कहीन को तर्कहीन डिग्री तक बढ़ाते हैं) तर्कसंगत परिणाम नहीं लौटाते हैं, लेकिन क्योंकि विकल्पों की संख्या कम है। इसलिए, एक और सामान्यीकरण उत्पन्न होता है:

किसी पूर्णांक के लिए यह सिद्ध या अस्वीकृत करना कि यह सत्य है: यदि तनेझी समस्या के लिए आरोही क्रम में समस्या का समाधान नहीं होता है जिसमें आउटपुट के सभी पुनरावृत्तियों को वैक्टर पर किया जाता है जिसमें तर्कहीन तत्व नहीं होते हैं, तो इसका कोई हल नहीं है।

निर्णय की प्रगति

शुरू करने के लिए, हम उन सभी निष्कर्षों की संख्या गिनने के कार्य को लागू करते हैं जिन्हें कुछ के लिए समाधान माना जा सकता है - जरूरी नहीं कि पूरे (यानी, सभी निष्कर्ष जिसके लिए कोड 1 के साथ ऑपरेशन केवल परमाणु ऑपरेंड पर किया जाता है)। कार्यान्वयन भाषा C # है।

हमें मिला:

static long Num_0(bool[] A)
        {
            if (A.Length == 1)
            {
                return 1;
            }
            else
            {
                long res = 0;
                for (int i = 0; i < A.Length - 1; i++)
                {
                    bool[] B = new bool[A.Length - 1];
                    for (int j = 0; j < i; j++)
                        B[j] = A[j];
                    for (int j = i + 1; j < A.Length-1; j++)
                        B[j] = A[j+1];
                    if (A[i] && A[i + 1])
                    {
                        B[i] = true; //B[i] result for A[i]||A[i+1]
                        res += Num_0(B);
                    }
                    B[i] = false; //B[i] result for A[i] op A[i+1], op!=||
                    res += 6 * Num_0(B);
                }
                return res;
            }
        }

        static void Test_0(int range = 9, bool wait = true)
        {
            Console.WriteLine("Test 0 for [1.." + Convert.ToString(range) + "]");
            bool[] A = new bool[range];
            for (int i = 0; i < range; i++)
                A[i] = true; //each basic element is concatenable 
            string s = "Eq count: " + Convert.ToString(Num_0(A));
            Console.WriteLine(s);
            if (wait) Console.ReadLine();
            else
                Console.WriteLine();
        }

कार्यक्रम का परिणाम:

Test 0 for [1..9]
Eq count: 112274877312

हमें लगभग 112 बिलियन विकल्प मिले। निर्माण से, कई आउटपुट विकल्प न केवल एक ही मूल्य का उत्पादन करेंगे, बल्कि एक ही इनफ़िक्स प्रतिनिधित्व भी होगा (वांछित संख्या प्राप्त करें, एक ही ऑपरेटरों का उपयोग करके, एक ही ऑपरेंड पर, लेकिन एक अलग क्रम में)। उदाहरण के लिए, यदि पहले पुनरावृत्ति तत्वों को परिवर्तित करता है

$1$ तथा

$2$ पर

$1+2=3$ , और दूसरा तत्व

$3$ तथा

$3$ पर

$3+3=6$ और अगर पहली पुनरावृत्ति तत्वों को परिवर्तित करती है

$2$ तथा

$3$ पर

$2+3=5$ , और दूसरा तत्व

$1$ तथा

$5$ पर

$1+5=6$ , तो दोनों ही मामलों में हमें एक infix अभिव्यक्ति मिलती है:

$1+2+3=6$

हम एक दोहराए गए परिणाम के साथ इंफ़िक्स के कुछ वर्गों का वर्णन करते हैं:

अतिरिक्त ऑपरेटर को ऑपरेंड पर किया जाता है, जिनमें से एक जोड़ का परिणाम है, फिर हम खुद को पुनरावृत्तियों तक सीमित कर सकते हैं जिसमें सही ऑपरेंड जोड़ का परिणाम नहीं है और पिछले गणना का परिणाम एक तत्व है जिसका सूचकांक सबसे अधिक है $ind+1$ . $1+(2+3)$ $(1+2)+3$ , $1+2+3+4*(5+6)$ $5+6$ $1+2+3$ ,
: ,
, 7, : ${({a^b})}^c={{(a^{-b}})}^{-}$ , , , $a^{-b}$ $a^b$
( ) , .. . : $a*(b/c) = a*b/c$ $a/(b/c)=a/b*c$

इन वर्गों को ध्यान में रखते हुए ऑपरेटरों के कार्यान्वयन में इन्फिनिक्स अभिव्यक्तियों के बीच पुनरावृत्ति की अनुपस्थिति की गारंटी नहीं है, लेकिन बीओओ आपको इनमें से कुछ पुनरावृत्ति को त्यागने की अनुमति देता है।

मशीन के शब्द के सीमित आकार के कारण, कुछ निष्कर्षों के लिए वैक्टर के तत्वों के मूल्यों की गणना नहीं की जाती है। BigInteger डेटा प्रकार का उपयोग करके, इनमें से कुछ मानों की गणना करना संभव होगा। वेक्टर तत्व के लिए डेटा संरचना की घोषणा करें। इसमें दो लंबे पूर्णांक होंगे, जो कुछ परिमेय संख्या के अंश और हर का प्रतिनिधित्व करते हैं। प्रत्येक ऑपरेटर के लिए, हम बिना अतिप्रवाह के तर्कसंगत परिणाम की गारंटी के लिए कई अतिरिक्त शर्तें लिखते हैं। एक ही संरचना में infix मानों को दोहराने के वर्गों पर संचालन कोड और प्रतिबंधों को जोड़ते हुए, हम फ़ंक्शन Num_1 प्राप्त करते हैं, जो BOO विभिन्न infix निरूपण वाले निष्कर्षों की संख्या को गिनाता है। जाहिर है, कोई समाधान नहीं खो जाएगा, इस अर्थ में कि अगर एक निश्चित संख्या के लिए न्यूम_0 में न्यूनतम 1 आउटपुट था,तब इसके लिए Num_1 में कम से कम एक आउटपुट होगा।

हमें मिला

        public struct NumEx
        {
            public NumEx(BigInteger x, BigInteger y, int opcode)
            {
                X = x;
                Y = y;
                OpCode = opcode;
                Eq = X.ToString();
            }

            public BigInteger X { get; set; }
            public BigInteger Y { get; set; }
            public int OpCode { get; set; }

            public string Eq { get; set; }

            public override string ToString() => $"({X}/{Y}) [{Eq}]";
        }

        static long Num_1(NumEx[] A, int pos = -1)
        {
            if (A.Length == 1)
                return 1;
            else
            {
                long res = 0;
                for (int i = 0; i < A.Length - 1; i++)
                    if ((A[i + 1].OpCode != 0) || (pos == -1) || (pos >= i))
                    {
                        NumEx[] B = new NumEx[A.Length - 1];
                        for (int j = 0; j < i; j++)
                            B[j] = A[j];
                        for (int j = i + 1; j < A.Length - 1; j++)
                            B[j] = A[j + 1];
                        if ((A[i].OpCode < 2) && (A[i + 1].OpCode == 0))
                        {
                            // concat
                            B[i].OpCode = 1;
                            res += Num_1(B, i);
                        }
                        if (A[i + 1].OpCode != 2)
                        {
                            //+ -
                            B[i].OpCode = 2;
                            res += 2 * Num_1(B, i);
                        }
                        if (A[i + 1].OpCode != 3)
                        {
                            //* /
                            B[i].OpCode = 3;
                            res += 2 * Num_1(B, i);
                        }
                        {
                            //^ ^-
                            B[i].OpCode = 4;
                            if (A[i].OpCode == 4)
                                res += Num_1(B, i);
                            else
                                res += 2 * Num_1(B, i);
                        }
                    }
                return res;
            }
        }

        static void Test_1(int range = 9, bool wait = true)
        {
            Console.WriteLine("Test 1 for [1.." + Convert.ToString(range) + "]");
            NumEx[] A = new NumEx[range];
            for (int i = 0; i < range; i++)
                A[i] = new NumEx(i + 1, 1, 0);
            string s = "Eq count: " + Convert.ToString(Num_1(A));
            Console.WriteLine(s);
            if (wait) Console.ReadLine();
            else
                Console.WriteLine();
        }

नए परीक्षण का परिणाम:

Test 1 for [1..9]
Eq count: 4762796551

लगभग 4762 मिलियन अभिव्यक्ति प्राप्त की।

वेक्टर तत्व के लिए डेटा संरचना में, हम एक स्ट्रिंग फ़ील्ड भी बनाते हैं जिसमें आउटपुट का infix प्रतिनिधित्व जमा होगा। पुनरावृत्ति श्रृंखला के अंत में (जब लंबाई की एक सरणी के साथ Num_2 फ़ंक्शन को पुन: कॉल कर रहे हैं), हम इस वेक्टर के एक तत्व का प्रतिनिधित्व करने वाले अंश की सिकुड़न की जांच करेंगे और एक निश्चित संख्या के साथ हर के अंश को विभाजित करने के परिणाम की तुलना करेंगे। काउंटर चर में प्रवेश करते हुए, हमें एक प्रक्रिया मिलती है, जिसके परिणामस्वरूप दिए गए शर्तों के साथ संख्या घाटी के आउटपुट की संख्या होगी। संख्या के लिए

$10958$ तथा

$5479=10958/2$ (कहाँ पे

$5479$ - सरल) हमें मिलता है:

स्रोत

        public struct NumEx
        {
            public NumEx(BigInteger x, BigInteger y, int opcode)
            {
                X = x;
                Y = y;
                OpCode = opcode;
                Eq = X.ToString();
            }

            public BigInteger X { get; set; }
            public BigInteger Y { get; set; }
            public int OpCode { get; set; }

            public string Eq { get; set; }

            public override string ToString() => $"({X}/{Y}) [{Eq}]";
        }
        static long PowLimit = 27;
        static long SolLimit = 400;
        static long SolCount = 0;
        static long Num_2(NumEx[] A, long val, int pos = -1)
        {
            if (A.Length == 1)
            {
                if ((A[0].X % A[0].Y) == 0)
                {
                    BigInteger B = BigInteger.Divide(A[0].X, A[0].Y);
                    if (B == new BigInteger(val))
                    {
                        SolCount++;
                        if (SolCount <= SolLimit)
                        {
                            Console.WriteLine(Convert.ToString(val) + " = " + A[0].Eq);
                        }
                    }
                }
                return 1;
            }
            else
            {
                long res = 0;
                for (int i = 0; i < A.Length - 1; i++)
                    if ((A[i + 1].OpCode != 0) || (pos == -1) || (pos >= i))
                    {
                        NumEx[] B = new NumEx[A.Length - 1];
                        for (int j = 0; j < i; j++)
                            B[j] = A[j];
                        for (int j = i + 1; j < A.Length - 1; j++)
                            B[j] = A[j + 1];

                        if ((A[i].OpCode < 2) && (A[i + 1].OpCode == 0))
                        {
                            // concat
                            int p = A[i + 1].X.ToString().Length;
                            B[i].X = BigInteger.Add(A[i + 1].X, BigInteger.Multiply(A[i].X,
                                BigInteger.Pow(new BigInteger(10), p)));
                            B[i].Y = 1;
                            B[i].OpCode = 1;
                            B[i].Eq = A[i].Eq + A[i + 1].Eq;
                            res += Num_2(B, val, i);
                        }

                        if ((A[i + 1].X % A[i + 1].Y) == 0)
                        {
                            //pow
                            BigInteger pow = BigInteger.Divide(A[i + 1].X, A[i + 1].Y);
                            if (pow <= PowLimit)
                            {
                                if (pow.IsZero)
                                {
                                    B[i].X = 1;
                                    B[i].Y = 1;
                                    B[i].OpCode = 4;
                                    string s1 = A[i].Eq;
                                    string s2 = A[i + 1].Eq;
                                    if (A[i].OpCode > 1)
                                        s1 = "(" + s1 + ")";
                                    if (A[i+1].OpCode > 1)
                                        s2 = "(" + s2 + ")";
                                    B[i].Eq = s1 + "^" + s2;
                                    res += Num_2(B, val, i);
                                }
                                else
                                {
                                    //^
                                    int p = (int)pow;
                                    BigInteger val1 = BigInteger.Pow(A[i].X, p);
                                    BigInteger val2 = BigInteger.Pow(A[i].Y, p);
                                    B[i].X = val1;
                                    B[i].Y = val2;
                                    B[i].OpCode = 4;
                                    string s1 = A[i].Eq;
                                    string s2 = A[i + 1].Eq;
                                    if (A[i].OpCode > 1)
                                        s1 = "(" + s1 + ")";
                                    if (A[i + 1].OpCode > 1)
                                        s2 = "(" + s2 + ")";
                                    B[i].Eq = s1 + "^" + s2;
                                    res += Num_2(B, val, i);
                                    //^-
                                    if ((!val1.IsZero) && (A[i].OpCode != 4))
                                    {
                                        B[i].X = val2;
                                        B[i].Y = val1;
                                        B[i].OpCode = 4;
                                        s1 = A[i].Eq;
                                        s2 = A[i + 1].Eq;
                                        if (A[i].OpCode > 1)
                                            s1 = "(" + s1 + ")";
                                        if (A[i + 1].OpCode > 1)
                                            s2 = "(" + s2 + ")";
                                        B[i].Eq = s1 + "^-" + s2;
                                        res += Num_2(B, val, i);
                                    }
                                }
                            }
                        }
                        if ((A[i + 1].X != 0) && (A[i + 1].OpCode != 3))
                        {
                            //div
                            B[i].X = BigInteger.Multiply(A[i].X, A[i + 1].Y);
                            B[i].Y = BigInteger.Multiply(A[i].Y, A[i + 1].X);
                            B[i].OpCode = 3;
                            string s1 = A[i].Eq;
                            string s2 = A[i + 1].Eq;
                            if (A[i].OpCode > 1)
                                s1 = "(" + s1 + ")";
                            if ((A[i + 1].OpCode > 1)||(s2.ToArray()[0]=='-'))
                                s2 = "(" + s2 + ")";
                            B[i].Eq = s1+ "/" + s2;
                            res += Num_2(B, val, i);
                        }
                        if (A[i + 1].OpCode != 3)
                        {
                            //mul
                            B[i].X = BigInteger.Multiply(A[i].X, A[i + 1].X);
                            B[i].Y = BigInteger.Multiply(A[i].Y, A[i + 1].Y);
                            B[i].OpCode = 3;
                            string s1 = A[i].Eq;
                            string s2 = A[i + 1].Eq;
                            if (A[i].OpCode > 1)
                                s1 = "(" + s1 + ")";
                            if ((A[i + 1].OpCode > 1) || (s2.ToArray()[0] == '-'))
                                s2 = "(" + s2 + ")";
                            B[i].Eq = s1 + "*" + s2;
                            res += Num_2(B, val, i);
                        }
                        if (A[i + 1].OpCode != 2)
                        {
                            //add
                            B[i].X = BigInteger.Add(BigInteger.Multiply(A[i].X, A[i + 1].Y),
                                BigInteger.Multiply(A[i].Y, A[i + 1].X));
                            B[i].Y = BigInteger.Multiply(A[i].Y, A[i + 1].Y);
                            B[i].OpCode = 2;
                            string s1 = A[i].Eq;
                            string s2 = A[i + 1].Eq;
                            if (s2.ToArray()[0] == '-')
                                s2 = "(" + s2 + ")";
                            B[i].Eq = s1 + "+" + s2;
                            res += Num_2(B, val, i);
                            //sub -abs
                            B[i].X = 
                                BigInteger.Subtract(BigInteger.Multiply(A[i].X, A[i + 1].Y),
                                BigInteger.Multiply(A[i].Y, A[i + 1].X));
                            bool neg = B[i].X < BigInteger.Zero;
                            if (neg) B[i].X = BigInteger.Abs(B[i].X);
                            B[i].Y = BigInteger.Multiply(A[i].Y, A[i + 1].Y);
                            B[i].OpCode = 2;
                            s1 = A[i].Eq;
                            s2 = A[i + 1].Eq;
                            if (A[i].OpCode > 1)
                                s1 = "(" + s1 + ")";
                            if ((A[i + 1].OpCode > 1) || (s2.ToArray()[0] == '-'))
                                s2 = "(" + s2 + ")";
                            if (neg)
                                B[i].Eq = "(-" + s1 + ")+" + s2; //?
                            else
                                B[i].Eq = s1 + "-" + s2;
                            res += Num_2(B, val, i);
                        }
                    }

                return res;
            }
        }

        static void Test_2(long val, int range = 9, bool wait = true, long out_lim = 400, long pow_lim = 27)
        {
            Console.WriteLine("Test 2 for [1.." + Convert.ToString(range) + "]");
            NumEx[] A = new NumEx[range];
            for (int i = 0; i < range; i++)
                A[i] = new NumEx(i + 1, 1, 0);
            SolCount = 0;
            SolLimit = out_lim;
            PowLimit = pow_lim;
            Console.WriteLine("Max power: " + Convert.ToString(PowLimit) + ", output limit: " 
                + Convert.ToString(SolLimit));
            string s = "Eq count: " + Convert.ToString(Num_2(A, val));
            Console.WriteLine(s);
            Console.WriteLine("Total solutions count for " + Convert.ToString(val) + ": " 
                + Convert.ToString(SolCount));
            if (wait) Console.ReadLine();
            else
                Console.WriteLine();
        }

आउटपुट में निष्कर्षों की संख्या होगी, जिसके परिणाम की सही गणना की जा सकती थी, साथ ही उनकी संख्या के सभी निष्कर्षों के लिए infix अभिव्यक्तियों की गणना की गई थी, जो कि वैल्यू प्राप्त करने के साथ समाप्त हुई थी।

परिणाम

Test 2 for [1..9]
Max power: 27, output limit: 400
Eq count: 957441620
Total solutions count for 10958: 0

Test 2 for [1..9]
Max power: 27, output limit: 400
5479 = ((1+2*(345-6)+7)*8)-9
5479 = ((((-((-1)+23))+((4*5)*6))*7)*8)-9
5479 = 1+(2*3)*((((4*5)*6)-7)*8+9)
5479 = (((((-1)+(2^3))*((4*5)-6))*7)*8)-9
5479 = ((((1+2*3)*((4*5)-6))*7)*8)-9
5479 = ((((((-1)+(2^3))/4)*56)*7)*8)-9
5479 = (((((1+2*3)/4)*56)*7)*8)-9
5479 = ((((1^2+3/4)*56)*7)*8)-9
5479 = ((((1^-2+3/4)*56)*7)*8)-9
5479 = (((((-1)+2+3/4)*56)*7)*8)-9
5479 = ((((1*2)*((-(3+4))+56))*7)*8)-9
5479 = ((((1*2)*((-(3+4))+56))*7)*8)-9
5479 = 1*((((2*((-(3+4))+56))*7)*8)-9)
5479 = ((123-4+567)*8)-9
5479 = (-(1*2))+((34+567+8)*9)
5479 = (-(1*2))+((34+567+8)*9)
5479 = 1*((-2)+((34+567+8)*9))
5479 = ((((1/2+3)*4)*(56-7))*8)-9
5479 = (((1*2+3*4)*(56-7))*8)-9
5479 = (((1*(2+3*4))*(56-7))*8)-9
5479 = 1*((((2+3*4)*(56-7))*8)-9)
5479 = ((((1*2)*(3+4))*(56-7))*8)-9
5479 = 1*((((2*(3+4))*(56-7))*8)-9)
5479 = 1+(2+3^4)*(56-7+8+9)
5479 = ((((1*2)*34+5*6)*7)*8)-9
5479 = (((1*(2*34+5*6))*7)*8)-9
5479 = 1*((((2*34+5*6)*7)*8)-9)
5479 = (((((1/2)^-(3+4))-(5*6))*7)*8)-9
5479 = (((((1*2)^(3+4))-(5*6))*7)*8)-9
5479 = ((((1*(2^(3+4)))-(5*6))*7)*8)-9
5479 = (((1*((2^(3+4))-(5*6)))*7)*8)-9
5479 = 1*(((((2^(3+4))-(5*6))*7)*8)-9)
5479 = ((((1/(2^-(3+4)))-(5*6))*7)*8)-9
5479 = ((((-1)+((2+3+4)*(5+6)))*7)*8)-9
5479 = (-(1*2))+(((-(3+4))+(((5+6)*7)*8))*9)
5479 = (-(1*2))+(((-(3+4))+(((5+6)*7)*8))*9)
5479 = 1*((-2)+(((-(3+4))+(((5+6)*7)*8))*9))
5479 = (((12/3)*4)*(5*67+8))-9
5479 = (((12/3)*4)*(5*67+8))-9
5479 = (((12/3)*4)*(5*67+8))-9
5479 = (((1^2+3)*4)*(5*67+8))-9
5479 = (((1^2+3)*4)*(5*67+8))-9
5479 = ((((-(1^2))+3)^4)*(5*67+8))-9
5479 = ((((-(1^2))+3)^4)*(5*67+8))-9
5479 = (((1^2+3)*4)*(5*67+8))-9
5479 = ((((-(1^2))+3)^4)*(5*67+8))-9
5479 = (((1^-2+3)*4)*(5*67+8))-9
5479 = (((1^-2+3)*4)*(5*67+8))-9
5479 = ((((-(1^-2))+3)^4)*(5*67+8))-9
5479 = ((((-(1^-2))+3)^4)*(5*67+8))-9
5479 = (((1^-2+3)*4)*(5*67+8))-9
5479 = ((((-(1^-2))+3)^4)*(5*67+8))-9
5479 = ((((-1)+2+3)*4)*(5*67+8))-9
5479 = ((((-1)+2+3)*4)*(5*67+8))-9
5479 = ((((-((-1)+2))+3)^4)*(5*67+8))-9
5479 = ((((-((-1)+2))+3)^4)*(5*67+8))-9
5479 = ((((-1)+2+3)*4)*(5*67+8))-9
5479 = ((((-((-1)+2))+3)^4)*(5*67+8))-9
5479 = ((((-1)+((2+3)^4))-5+67)*8)-9
5479 = (-1)+(2^3)+((4+5+67)*8)*9
5479 = (-1)+(2^3)+((4+5+67)*8)*9
5479 = 1+(2/3+(4+5+67)*8)*9
5479 = 1+2*3+((4+5+67)*8)*9
5479 = 1+2*3+((4+5+67)*8)*9
5479 = 1+(2/3+(4+5+67)*8)*9
5479 = (-1)+(2^3)+((4+5+67)*8)*9
5479 = 1+2*3+((4+5+67)*8)*9
5479 = (((12/3)*4)*(5*67+8))-9
5479 = (((1^2+3)*4)*(5*67+8))-9
5479 = ((((-(1^2))+3)^4)*(5*67+8))-9
5479 = (((1^-2+3)*4)*(5*67+8))-9
5479 = ((((-(1^-2))+3)^4)*(5*67+8))-9
5479 = ((((-1)+2+3)*4)*(5*67+8))-9
5479 = ((((-((-1)+2))+3)^4)*(5*67+8))-9
5479 = (1*2)*(3+4*(5+678))+9
5479 = (1*2)*(3+4*(5+678))+9
5479 = (1*2)*(3+4*(5+678))+9
5479 = (1*2)*(3+4*(5+678))+9
5479 = 1*(2*(3+4*(5+678))+9)
5479 = 1+(2+3^4)*((5*(6+7))-8+9)
5479 = 1+(2+3^4)*((5*(6+7))-8+9)
5479 = 1+(2+3^4)*((5*(6+7))-8+9)
5479 = (-(1*2))+(((34-5)*(6+7+8))*9)
5479 = (-(1*2))+(((34-5)*(6+7+8))*9)
5479 = 1*((-2)+(((34-5)*(6+7+8))*9))
5479 = (-1)+((2+3)*(4^5+(((-6)+7)*8)*9))
5479 = (-1)+((2+3)*(4^5+(((-6)+7)*8)*9))
5479 = (-(1*2))+(((3^4)-5)*((-6)+78))+9
5479 = 1+2*((34-5+6)*78+9)
5479 = (-(1*2))+(((3^4)-5)*((-6)+78))+9
5479 = (-(1*2))+(((3^4)-5)*((-6)+78))+9
5479 = (-(1*2))+(((3^4)-5)*((-6)+78))+9
5479 = (-(1*2))+(((3^4)-5)*((-6)+78))+9
5479 = 1*((-2)+(((3^4)-5)*((-6)+78)))+9
5479 = 1*((-2)+(((3^4)-5)*((-6)+78))+9)
5479 = (-(1*2))+(((3^4)-5)*((-6)+78))+9
5479 = (-(1*2))+(((3^4)-5)*((-6)+78))+9
5479 = 1*((-2)+(((3^4)-5)*((-6)+78)))+9
5479 = 1*((-2)+(((3^4)-5)*((-6)+78))+9)
5479 = 1+(((2/3)*(4^5+6))-78)*9
5479 = (-(1*2))+(((3^4)-5)*((-6)+78))+9
5479 = (-(1*2))+(((3^4)-5)*((-6)+78))+9
5479 = 1*((-2)+(((3^4)-5)*((-6)+78)))+9
5479 = 1*((-2)+(((3^4)-5)*((-6)+78))+9)
5479 = (-(1*2))+(((3*4)-5)*((-6)+789))
5479 = (-(1*2))+(((3*4)-5)*((-6)+789))
5479 = (-(1*2))+(((3*4)-5)*((-6)+789))
5479 = (-(1*2))+(((3*4)-5)*((-6)+789))
5479 = (-(1*2))+(((3*4)-5)*((-6)+789))
5479 = 1*((-2)+(((3*4)-5)*((-6)+789)))
5479 = (-(1*2))+(((3*4)-5)*((-6)+789))
5479 = (-(1*2))+(((3*4)-5)*((-6)+789))
5479 = 1*((-2)+(((3*4)-5)*((-6)+789)))
5479 = (-(1*2))+(((3*4)-5)*((-6)+789))
5479 = (-(1*2))+(((3*4)-5)*((-6)+789))
5479 = 1*((-2)+(((3*4)-5)*((-6)+789)))
5479 = (1+(2*3+4^5)*6)-(78*9)
5479 = (1+(2*3)*(4^5+6))-(78*9)
5479 = (-(1*2))+((3+4+56)*(78+9))
5479 = (-(1*2))+((3+4+56)*(78+9))
5479 = (-(1*2))+((3+4+56)*(78+9))
5479 = 1*((-2)+((3+4+56)*(78+9)))
5479 = 1+(2+3^4)*((-5)+6+7*8+9)
5479 = 1+(2+3^4)*((-5)+6+7*8+9)
5479 = 1+(2+3^4)*((-5)+6+7*8+9)
5479 = 1+2*(3+456*((7+8)-9))
5479 = 1+((2+3^4)*(5+6))*((7+8)-9)
5479 = (((-((-1)+(2^3)))+(4^5))*6)-(7*89)
5479 = (((-((-1)+(2^3)))+(4^5))*6)-(7*89)
5479 = (((-(1+2*3))+(4^5))*6)-(7*89)
5479 = (((-(1+2*3))+(4^5))*6)-(7*89)
5479 = (((-((-1)+(2^3)))+(4^5))*6)-(7*89)
5479 = (((-((-1)+(2^3)))+(4^5))*6)-(7*89)
5479 = (((-((-1)+(2^3)))+(4^5))*6)-(7*89)
5479 = (((-((-1)+(2^3)))+(4^5))*6)-(7*89)
5479 = (((-(1+2*3))+(4^5))*6)-(7*89)
5479 = (((-(1+2*3))+(4^5))*6)-(7*89)
5479 = (((-(1+2*3))+(4^5))*6)-(7*89)
5479 = (((-(1+2*3))+(4^5))*6)-(7*89)
5479 = (((-((-1)+(2^3)))+(4^5))*6)-(7*89)
5479 = (((-(1+2*3))+(4^5))*6)-(7*89)
5479 = (-((1/2)^-(3+4)))+((56+7)*89)
5479 = (-((1*2)^(3+4)))+((56+7)*89)
5479 = (-((1/2)^-(3+4)))+((56+7)*89)
5479 = (-((1/2)^-(3+4)))+((56+7)*89)
5479 = (-((1*2)^(3+4)))+((56+7)*89)
5479 = (-((1*2)^(3+4)))+((56+7)*89)
5479 = (-(1*(2^(3+4))))+((56+7)*89)
5479 = (-(1*(2^(3+4))))+((56+7)*89)
5479 = 1*((-(2^(3+4)))+((56+7)*89))
5479 = (-(1/(2^-(3+4))))+((56+7)*89)
5479 = (-(1/(2^-(3+4))))+((56+7)*89)
5479 = (-((1/2)^-(3+4)))+((56+7)*89)
5479 = (-((1*2)^(3+4)))+((56+7)*89)
5479 = (-(1*(2^(3+4))))+((56+7)*89)
5479 = 1*((-(2^(3+4)))+((56+7)*89))
5479 = (-(1/(2^-(3+4))))+((56+7)*89)
5479 = (-((1/2)^-(3+4)))+((56+7)*89)
5479 = (-((1*2)^(3+4)))+((56+7)*89)
5479 = (-(1*(2^(3+4))))+((56+7)*89)
5479 = 1*((-(2^(3+4)))+((56+7)*89))
5479 = (-(1/(2^-(3+4))))+((56+7)*89)
5479 = 1+(2+3^4)*((-((5*6)-7))+89)
5479 = 1+(2+3^4)*((-((5*6)-7))+89)
5479 = 1+(2+3^4)*((-((5*6)-7))+89)
5479 = ((1/2)/3)^-4+(5+6*7)*89
5479 = ((1/2)/3)^-4+(5+6*7)*89
5479 = ((1/2)/3)^-4+(5+6*7)*89
5479 = ((1/2)/3)^-4+(5+6*7)*89
5479 = ((1/2)/3)^-4+(5+6*7)*89
5479 = ((1/2)/3)^-4+(5+6*7)*89
5479 = ((1*2)*3)^4+(5+6*7)*89
5479 = ((1*2)*3)^4+(5+6*7)*89
5479 = ((1*2)*3)^4+(5+6*7)*89
5479 = ((1*2)*3)^4+(5+6*7)*89
5479 = ((1*2)*3)^4+(5+6*7)*89
5479 = ((1*2)*3)^4+(5+6*7)*89
5479 = (1+2+3)^4+(5+6*7)*89
5479 = (1+2+3)^4+(5+6*7)*89
5479 = (1+2+3)^4+(5+6*7)*89
5479 = (1+2+3)^4+(5+6*7)*89
5479 = (1+2+3)^4+(5+6*7)*89
5479 = (1+2+3)^4+(5+6*7)*89
5479 = 1*((2*3)^4)+(5+6*7)*89
5479 = 1*((2*3)^4)+(5+6*7)*89
5479 = 1*((2*3)^4)+(5+6*7)*89
5479 = 1*((2*3)^4+(5+6*7)*89)
5479 = 1/((2*3)^-4)+(5+6*7)*89
5479 = 1/((2*3)^-4)+(5+6*7)*89
5479 = 1/((2*3)^-4)+(5+6*7)*89
5479 = 1*((2*3)^4)+(5+6*7)*89
5479 = 1*((2*3)^4)+(5+6*7)*89
5479 = 1*((2*3)^4+(5+6*7)*89)
5479 = 1/((2*3)^-4)+(5+6*7)*89
5479 = 1/((2*3)^-4)+(5+6*7)*89
5479 = 1*((2*3)^4)+(5+6*7)*89
5479 = 1*((2*3)^4+(5+6*7)*89)
5479 = 1/((2*3)^-4)+(5+6*7)*89
5479 = ((1/2)/3)^-4+(5+6*7)*89
5479 = ((1/2)/3)^-4+(5+6*7)*89
5479 = ((1/2)/3)^-4+(5+6*7)*89
5479 = ((1*2)*3)^4+(5+6*7)*89
5479 = ((1*2)*3)^4+(5+6*7)*89
5479 = ((1*2)*3)^4+(5+6*7)*89
5479 = (1+2+3)^4+(5+6*7)*89
5479 = (1+2+3)^4+(5+6*7)*89
5479 = (1+2+3)^4+(5+6*7)*89
5479 = 1*((2*3)^4)+(5+6*7)*89
5479 = 1*((2*3)^4)+(5+6*7)*89
5479 = 1*((2*3)^4+(5+6*7)*89)
5479 = 1/((2*3)^-4)+(5+6*7)*89
5479 = 1/((2*3)^-4)+(5+6*7)*89
5479 = 1*((2*3)^4)+(5+6*7)*89
5479 = 1*((2*3)^4+(5+6*7)*89)
5479 = 1/((2*3)^-4)+(5+6*7)*89
5479 = ((1/2)/3)^-4+(5+6*7)*89
5479 = ((1*2)*3)^4+(5+6*7)*89
5479 = (1+2+3)^4+(5+6*7)*89
5479 = 1*((2*3)^4)+(5+6*7)*89
5479 = 1*((2*3)^4+(5+6*7)*89)
5479 = 1/((2*3)^-4)+(5+6*7)*89
5479 = (((-((-1)+(2^3)))+(4^5))*6)-(7*89)
5479 = (((-(1+2*3))+(4^5))*6)-(7*89)
5479 = 1+2*((((3^(4+5))-6)/7)-(8*9))
5479 = 1+(2+3^4)*((-((-((-5)+6))+7))+(8*9))
5479 = 1+(2+3^4)*((-((-((-5)+6))+7))+(8*9))
5479 = 1+(2+3^4)*((-((-((-5)+6))+7))+(8*9))
5479 = ((((12^3)/4)-5)*(6+7))-(8*9)
5479 = (-1)+((2+3)*(4^(5^((-6)+7))+8*9))
5479 = (-1)+((2+3)*(4^(5/((-6)+7))+8*9))
5479 = (-1)+((2+3)*(4^(5*((-6)+7))+8*9))
5479 = (-1)+((2+3)*((4^5)^((-6)+7)+8*9))
5479 = (-1)+((2+3)*((4^5)/((-6)+7)+8*9))
5479 = (-1)+((2+3)*((4^5)*((-6)+7)+8*9))
5479 = (-1)+((2+3)*((4^5)^((-6)+7)+8*9))
5479 = (-1)+((2+3)*((4^5)^((-6)+7)+8*9))
5479 = (-1)+((2+3)*((4^5)/((-6)+7)+8*9))
5479 = (-1)+((2+3)*((4^5)/((-6)+7)+8*9))
5479 = (-1)+((2+3)*((4^5)*((-6)+7)+8*9))
5479 = (-1)+((2+3)*((4^5)*((-6)+7)+8*9))
5479 = (-1)+((2+3)*(4^(5^((-6)+7))+8*9))
5479 = (-1)+((2+3)*(4^(5^((-6)+7))+8*9))
5479 = (-1)+((2+3)*(4^(5^((-6)+7))+8*9))
5479 = (-1)+((2+3)*(4^(5/((-6)+7))+8*9))
5479 = (-1)+((2+3)*(4^(5/((-6)+7))+8*9))
5479 = (-1)+((2+3)*(4^(5/((-6)+7))+8*9))
5479 = (-1)+((2+3)*(4^(5*((-6)+7))+8*9))
5479 = (-1)+((2+3)*(4^(5*((-6)+7))+8*9))
5479 = (-1)+((2+3)*(4^(5*((-6)+7))+8*9))
5479 = (-12)+(((-(3*4))+(5*67))*(8+9))
5479 = (-12)+(((-(3*4))+(5*67))*(8+9))
5479 = (-12)+(((-(3*4))+(5*67))*(8+9))
5479 = (-12)+(((-(3*4))+(5*67))*(8+9))
5479 = (-12)+(((-(3*4))+(5*67))*(8+9))
5479 = (-12)+(((-(3*4))+(5*67))*(8+9))
5479 = (-12)+(((-(3*4))+(5*67))*(8+9))
5479 = (-12)+(((-(3*4))+(5*67))*(8+9))
5479 = (12^3)*(4-(5/6))+7^((-8)+9)
5479 = (12^3)*(4-(5/6))+7/((-8)+9)
5479 = (12^3)*(4-(5/6))+7*((-8)+9)
5479 = (12*((3^4)-5))*6+7^((-8)+9)
5479 = (12^3)*(4-(5/6))+7^((-8)+9)
5479 = (12^3)*(4-(5/6))+7^((-8)+9)
5479 = (12*((3^4)-5))*6+7/((-8)+9)
5479 = (12^3)*(4-(5/6))+7/((-8)+9)
5479 = (12^3)*(4-(5/6))+7/((-8)+9)
5479 = (12*((3^4)-5))*6+7*((-8)+9)
5479 = (12^3)*(4-(5/6))+7*((-8)+9)
5479 = (12^3)*(4-(5/6))+7*((-8)+9)
5479 = (12*((3^4)-5))*6+7^((-8)+9)
5479 = (12*((3^4)-5))*6+7/((-8)+9)
5479 = (12*((3^4)-5))*6+7*((-8)+9)
5479 = ((12*((3^4)-5))*6+7)^((-8)+9)
5479 = ((12*((3^4)-5))*6+7)/((-8)+9)
5479 = ((12*((3^4)-5))*6+7)*((-8)+9)
5479 = (12*((3^4)-5))*6+7^((-8)+9)
5479 = (12*((3^4)-5))*6+7/((-8)+9)
5479 = (12*((3^4)-5))*6+7*((-8)+9)
5479 = (12*((3^4)-5))*6+7^((-8)+9)
5479 = (12*((3^4)-5))*6+7/((-8)+9)
5479 = (12*((3^4)-5))*6+7*((-8)+9)
5479 = (12*((3^4)-5))*6+7^((-8)+9)
5479 = (12*((3^4)-5))*6+7/((-8)+9)
5479 = (12*((3^4)-5))*6+7*((-8)+9)
5479 = (12*((3^4)-5))*6+7^((-8)+9)
5479 = (12*((3^4)-5))*6+7/((-8)+9)
5479 = (12*((3^4)-5))*6+7*((-8)+9)
5479 = (12*((3^4)-5))*6+7^((-8)+9)
5479 = (12*((3^4)-5))*6+7/((-8)+9)
5479 = (12*((3^4)-5))*6+7*((-8)+9)
5479 = ((12^3)*(4-(5/6))+7)^((-8)+9)
5479 = ((12^3)*(4-(5/6))+7)/((-8)+9)
5479 = ((12^3)*(4-(5/6))+7)*((-8)+9)
5479 = (12^3)*(4-(5/6))+7^((-8)+9)
5479 = (12^3)*(4-(5/6))+7/((-8)+9)
5479 = (12^3)*(4-(5/6))+7*((-8)+9)
5479 = (12^3)*(4-(5/6))+7^((-8)+9)
5479 = (12^3)*(4-(5/6))+7/((-8)+9)
5479 = (12^3)*(4-(5/6))+7*((-8)+9)
5479 = (12^3)*(4-(5/6))+7^((-8)+9)
5479 = (12^3)*(4-(5/6))+7/((-8)+9)
5479 = (12^3)*(4-(5/6))+7*((-8)+9)
5479 = ((12^3)*(4-(5/6))+7)^((-8)+9)
5479 = ((12^3)*(4-(5/6))+7)/((-8)+9)
5479 = ((12^3)*(4-(5/6))+7)*((-8)+9)
5479 = (12^3)*(4-(5/6))+7^((-8)+9)
5479 = (12^3)*(4-(5/6))+7/((-8)+9)
5479 = (12^3)*(4-(5/6))+7*((-8)+9)
5479 = (12^3)*(4-(5/6))+7^((-8)+9)
5479 = (12^3)*(4-(5/6))+7/((-8)+9)
5479 = (12^3)*(4-(5/6))+7*((-8)+9)
5479 = (12^3)*(4-(5/6))+7^((-8)+9)
5479 = (12^3)*(4-(5/6))+7/((-8)+9)
5479 = (12^3)*(4-(5/6))+7*((-8)+9)
5479 = (12^3)*(4-(5/6))+7^((-8)+9)
5479 = (12^3)*(4-(5/6))+7^((-8)+9)
5479 = (12^3)*(4-(5/6))+7/((-8)+9)
5479 = (12^3)*(4-(5/6))+7/((-8)+9)
5479 = (12^3)*(4-(5/6))+7*((-8)+9)
5479 = (12^3)*(4-(5/6))+7*((-8)+9)
5479 = ((12^3)*(4-(5/6))+7)^((-8)+9)
5479 = ((12^3)*(4-(5/6))+7)/((-8)+9)
5479 = ((12^3)*(4-(5/6))+7)*((-8)+9)
5479 = (12^3)*(4-(5/6))+7^((-8)+9)
5479 = (12^3)*(4-(5/6))+7/((-8)+9)
5479 = (12^3)*(4-(5/6))+7*((-8)+9)
5479 = (12^3)*(4-(5/6))+7^((-8)+9)
5479 = (12^3)*(4-(5/6))+7/((-8)+9)
5479 = (12^3)*(4-(5/6))+7*((-8)+9)
5479 = (12^3)*(4-(5/6))+7^((-8)+9)
5479 = (12^3)*(4-(5/6))+7/((-8)+9)
5479 = (12^3)*(4-(5/6))+7*((-8)+9)
5479 = (12^3)*(4-(5/6))+7^((-8)+9)
5479 = (12^3)*(4-(5/6))+7/((-8)+9)
5479 = (12^3)*(4-(5/6))+7*((-8)+9)
5479 = (12^3)*(4-(5/6))+7^((-8)+9)
5479 = (12^3)*(4-(5/6))+7^((-8)+9)
5479 = (12^3)*(4-(5/6))+7^((-8)+9)
5479 = (12^3)*(4-(5/6))+7/((-8)+9)
5479 = (12^3)*(4-(5/6))+7/((-8)+9)
5479 = (12^3)*(4-(5/6))+7/((-8)+9)
5479 = (12^3)*(4-(5/6))+7*((-8)+9)
5479 = (12^3)*(4-(5/6))+7*((-8)+9)
5479 = (12^3)*(4-(5/6))+7*((-8)+9)
5479 = (12*((3^4)-5))*6+7^((-8)+9)
5479 = (12^3)*(4-(5/6))+7^((-8)+9)
5479 = (12^3)*(4-(5/6))+7^((-8)+9)
5479 = (12^3)*(4-(5/6))+7^((-8)+9)
5479 = (12*((3^4)-5))*6+7/((-8)+9)
5479 = (12^3)*(4-(5/6))+7/((-8)+9)
5479 = (12^3)*(4-(5/6))+7/((-8)+9)
5479 = (12^3)*(4-(5/6))+7/((-8)+9)
5479 = (12*((3^4)-5))*6+7*((-8)+9)
5479 = (12^3)*(4-(5/6))+7*((-8)+9)
5479 = (12^3)*(4-(5/6))+7*((-8)+9)
5479 = (12^3)*(4-(5/6))+7*((-8)+9)
Eq count: 957441620
Total solutions count for 5479: 356

इसलिए, पूर्णांक की शक्तियों को पूर्ण मान में 27 से अधिक नहीं करने के लिए, ~ 957 मिलियन निष्कर्षों के परिणाम संगणनीय निकले, और उनमें से 356 संख्या 5479 के निष्कर्ष हैं और एक भी निष्कर्ष नहीं हैं (और तदनुसार जोड़, घटाव, निष्कर्ष, गुणन और विभाजन के संचालन के साथ एक भी निष्कर्ष नहीं निकला है। समान संचालन और कुछ पूर्णांक शक्तियों के साथ कुछ निष्कर्ष) संख्या 10958 का निष्कर्ष नहीं है। इसकी विशेषता क्या है?

भूत और छाया

आरोही क्रम में तनेझी समस्या के समान कार्य के लिए, लेकिन लंबाई 8 के प्रारंभिक वैक्टर के साथ, जैसे

$(1, 2, ... , 8)$ तथा

$(2, 3, ... , 9)$ विकल्पों की संख्या कम है, और वैक्टर (1) - (7) के तत्वों के तर्कहीन, जटिल और लंबे पूर्णांक मूल्यों के साथ, अनुकूलित वुल्फराम गणित एल्गोरिदम सामना करते हैं। इसलिए, यह विश्वसनीय रूप से ज्ञात है कि इसमें एक भी निष्कर्ष नहीं है

$(1, 2, ... , 9)$ , जिसके 8 वें पुनरावृत्ति पर संघनन, जोड़ या घटाव ऑपरेटर है, मूल्य 10958 तक नहीं जा सकता है। यह आगे के समाधान के लिए क्या संभावनाएं देता है?

संख्या 10958 अर्धविराम है। और अगर आउटपुट के अंतिम पुनरावृत्ति में इसके अलावा, घटाव और संघनन नहीं होता है, तो 8 वें पुनरावृत्ति में ऑपरेंड में से एक को कुछ मामलों में 5479 को कुछ हद तक शामिल करने की गारंटी दी जाएगी, दो मामलों को छोड़कर:

जब ऑपरेंड कुछ जटिल संयुग्म के गुणक होते हैं
जब किसी एक ऑपरेंड में एक लघुगणक होता है जिसका आधार या प्रतिपादक 5479 का गुणक होता है

और यदि पहला मामला एक ही वोल्फ्राम गणित की ताकत के भीतर है, तो दूसरे को अलग से माना जाना चाहिए। आज तक, एक निष्कर्ष नहीं मिला है जिसमें किसी भी पुनरावृत्ति पर आउटपुट वेक्टर का तत्व एक लघुगणक संतोषजनक मामला 2 था। इसके अलावा, एक सामान्य प्रमेय है:

प्रमेय 1: चलो $\alpha = log_ab$ कहाँ पे $a$ तथा $b$ - परस्पर सरल। फिर $\alpha$ एक मनमाना वेक्टर पर समर्पण नहीं $(c_1, c_2, ... , c_n)$ परिमित लंबाई n, कहाँ $c_1, c_2, ... , c_n$ - बीजीय पूर्णांक

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

परिभाषा: कुछ निष्कर्ष के कुछ पुनरावृत्ति पर दें

$(1, 2, ... , 9)$ परिणामी पुनरावृत्ति वेक्टर के तत्वों में से एक प्राइम पी के बराबर है, फिर इस तत्व के इन्फिक्स प्रतिनिधित्व को इस आउटपुट में पी का भूत कहा जाएगा

$(1, 2, ... , 9)$ ।

परिभाषा: कुछ निष्कर्ष के कुछ पुनरावृत्तियों पर दें

$(1, 2, ... , 9)$ परिणामी सदिश के तत्वों में से एक एक परिमेय संख्या है, जिसका अंश या भाजक एक अभाज्य संख्या p से विभाजित होता है, और यह तत्व भूत नहीं है, तो इस तत्व के infix निरूपण को इस आउटपुट में संख्या p की छाया कहा जाएगा

$(1, 2, ... , 9)$ ।

5479 नंबर के लिए भूतों और छायाओं की तालिका, Num_1 के निष्कर्षों की कुल संख्या से सैकड़ों-हजारों गुना छोटी होगी। इसके अलावा, मैन्युअल रूप से आउटपुट पुनरावृत्ति वेक्टर के अन्य तत्वों के साथ सुविधाओं को जोड़कर, जिस पर भूत या छाया पाए गए थे, निष्कर्ष तर्कहीन और जटिल डिग्री के साथ-साथ बड़े पूर्णांक और तर्कसंगत डिग्री के साथ प्राप्त किया जा सकता है, जिन्हें Num_2 में काट दिया गया था। हम भूत और छाया की खोज के लिए Num_3 फ़ंक्शन का वर्णन करते हैं और हमारी परियोजना में फ़ाइल आउटपुट जोड़ते हैं।

स्रोत

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;
using System.Numerics;

namespace ConsoleApp1
{
    class Program
    {
        static long Num_0(bool[] A)
        {
            if (A.Length == 1)
            {
                return 1;
            }
            else
            {
                long res = 0;
                for (int i = 0; i < A.Length - 1; i++)
                {
                    bool[] B = new bool[A.Length - 1];
                    for (int j = 0; j < i; j++)
                        B[j] = A[j];
                    for (int j = i + 1; j < A.Length-1; j++)
                        B[j] = A[j+1];
                    if (A[i] && A[i + 1])
                    {
                        B[i] = true; //B[i] result for A[i]||A[i+1]
                        res += Num_0(B);
                    }
                    B[i] = false; //B[i] result for A[i] op A[i+1], op!=||
                    res += 6 * Num_0(B);
                }
                return res;
            }
        }

        static void Test_0(int range = 9, bool wait = true)
        {
            Console.WriteLine("Test 0 for [1.." + Convert.ToString(range) + "]");
            F.WriteLine("Test 0 for [1.." + Convert.ToString(range) + "]");
            bool[] A = new bool[range];
            for (int i = 0; i < range; i++)
                A[i] = true; //each basic element is concatenable 
            string s = "Eq count: " + Convert.ToString(Num_0(A));
            Console.WriteLine(s);
            F.WriteLine(s);
            if (wait) Console.ReadLine();
            else
                Console.WriteLine();
            F.WriteLine();
        }

        public struct NumEx
        {
            public NumEx(BigInteger x, BigInteger y, int opcode)
            {
                X = x;
                Y = y;
                OpCode = opcode;
                Eq = X.ToString();
            }

            public BigInteger X { get; set; }
            public BigInteger Y { get; set; }
            public int OpCode { get; set; }

            public string Eq { get; set; }

            public override string ToString() => $"({X}/{Y}) [{Eq}]";
        }

        static long Num_1(NumEx[] A, int pos = -1)
        {
            if (A.Length == 1)
                return 1;
            else
            {
                long res = 0;
                for (int i = 0; i < A.Length - 1; i++)
                    if ((A[i + 1].OpCode != 0) || (pos == -1) || (pos >= i))
                    {
                        NumEx[] B = new NumEx[A.Length - 1];
                        for (int j = 0; j < i; j++)
                            B[j] = A[j];
                        for (int j = i + 1; j < A.Length - 1; j++)
                            B[j] = A[j + 1];
                        if ((A[i].OpCode < 2) && (A[i + 1].OpCode == 0))
                        {
                            // concat
                            B[i].OpCode = 1;
                            res += Num_1(B, i);
                        }
                        if (A[i + 1].OpCode != 2)
                        {
                            //+ -
                            B[i].OpCode = 2;
                            res += 2 * Num_1(B, i);
                        }
                        if (A[i + 1].OpCode != 3)
                        {
                            //* /
                            B[i].OpCode = 3;
                            res += 2 * Num_1(B, i);
                        }
                        {
                            //^ ^-
                            B[i].OpCode = 4;
                            if (A[i].OpCode == 4)
                                res += Num_1(B, i);
                            else
                                res += 2 * Num_1(B, i);
                        }
                    }
                return res;
            }
        }

        static void Test_1(int range = 9, bool wait = true)
        {
            Console.WriteLine("Test 1 for [1.." + Convert.ToString(range) + "]");
            F.WriteLine("Test 1 for [1.." + Convert.ToString(range) + "]");
            NumEx[] A = new NumEx[range];
            for (int i = 0; i < range; i++)
                A[i] = new NumEx(i + 1, 1, 0);
            string s = "Eq count: " + Convert.ToString(Num_1(A));
            Console.WriteLine(s);
            F.WriteLine(s);
            if (wait) Console.ReadLine();
            else
                Console.WriteLine();
            F.WriteLine();
        }

        static long PowLimit = 27;
        static long SolLimit = 400;
        static long SolCount = 0;
        static long Num_2(NumEx[] A, long val, int pos = -1)
        {
            if (A.Length == 1)
            {
                if ((A[0].X % A[0].Y) == 0)
                {
                    BigInteger B = BigInteger.Divide(A[0].X, A[0].Y);
                    if (B == new BigInteger(val))
                    {
                        SolCount++;
                        if (SolCount <= SolLimit)
                        {
                            Console.WriteLine(Convert.ToString(val) + " = " + A[0].Eq);
                            F.WriteLine(Convert.ToString(val) + " = " + A[0].Eq);
                        }
                    }
                }
                return 1;
            }
            else
            {
                long res = 0;
                for (int i = 0; i < A.Length - 1; i++)
                    if ((A[i + 1].OpCode != 0) || (pos == -1) || (pos >= i))
                    {
                        NumEx[] B = new NumEx[A.Length - 1];
                        for (int j = 0; j < i; j++)
                            B[j] = A[j];
                        for (int j = i + 1; j < A.Length - 1; j++)
                            B[j] = A[j + 1];

                        if ((A[i].OpCode < 2) && (A[i + 1].OpCode == 0))
                        {
                            // concat
                            int p = A[i + 1].X.ToString().Length;
                            B[i].X = BigInteger.Add(A[i + 1].X, BigInteger.Multiply(A[i].X,
                                BigInteger.Pow(new BigInteger(10), p)));
                            B[i].Y = 1;
                            B[i].OpCode = 1;
                            B[i].Eq = A[i].Eq + A[i + 1].Eq;
                            res += Num_2(B, val, i);
                        }

                        if ((A[i + 1].X % A[i + 1].Y) == 0)
                        {
                            //pow
                            BigInteger pow = BigInteger.Divide(A[i + 1].X, A[i + 1].Y);
                            if (pow <= PowLimit)
                            {
                                if (pow.IsZero)
                                {
                                    B[i].X = 1;
                                    B[i].Y = 1;
                                    B[i].OpCode = 4;
                                    string s1 = A[i].Eq;
                                    string s2 = A[i + 1].Eq;
                                    if (A[i].OpCode > 1)
                                        s1 = "(" + s1 + ")";
                                    if (A[i+1].OpCode > 1)
                                        s2 = "(" + s2 + ")";
                                    B[i].Eq = s1 + "^" + s2;
                                    res += Num_2(B, val, i);
                                }
                                else
                                {
                                    //^
                                    int p = (int)pow;
                                    BigInteger val1 = BigInteger.Pow(A[i].X, p);
                                    BigInteger val2 = BigInteger.Pow(A[i].Y, p);
                                    B[i].X = val1;
                                    B[i].Y = val2;
                                    B[i].OpCode = 4;
                                    string s1 = A[i].Eq;
                                    string s2 = A[i + 1].Eq;
                                    if (A[i].OpCode > 1)
                                        s1 = "(" + s1 + ")";
                                    if (A[i + 1].OpCode > 1)
                                        s2 = "(" + s2 + ")";
                                    B[i].Eq = s1 + "^" + s2;
                                    res += Num_2(B, val, i);
                                    //^-
                                    if ((!val1.IsZero) && (A[i].OpCode != 4))
                                    {
                                        B[i].X = val2;
                                        B[i].Y = val1;
                                        B[i].OpCode = 4;
                                        s1 = A[i].Eq;
                                        s2 = A[i + 1].Eq;
                                        if (A[i].OpCode > 1)
                                            s1 = "(" + s1 + ")";
                                        if (A[i + 1].OpCode > 1)
                                            s2 = "(" + s2 + ")";
                                        B[i].Eq = s1 + "^-" + s2;
                                        res += Num_2(B, val, i);
                                    }
                                }
                            }
                        }
                        if ((A[i + 1].X != 0) && (A[i + 1].OpCode != 3))
                        {
                            //div
                            B[i].X = BigInteger.Multiply(A[i].X, A[i + 1].Y);
                            B[i].Y = BigInteger.Multiply(A[i].Y, A[i + 1].X);
                            B[i].OpCode = 3;
                            string s1 = A[i].Eq;
                            string s2 = A[i + 1].Eq;
                            if (A[i].OpCode > 1)
                                s1 = "(" + s1 + ")";
                            if ((A[i + 1].OpCode > 1)||(s2.ToArray()[0]=='-'))
                                s2 = "(" + s2 + ")";
                            B[i].Eq = s1+ "/" + s2;
                            res += Num_2(B, val, i);
                        }
                        if (A[i + 1].OpCode != 3)
                        {
                            //mul
                            B[i].X = BigInteger.Multiply(A[i].X, A[i + 1].X);
                            B[i].Y = BigInteger.Multiply(A[i].Y, A[i + 1].Y);
                            B[i].OpCode = 3;
                            string s1 = A[i].Eq;
                            string s2 = A[i + 1].Eq;
                            if (A[i].OpCode > 1)
                                s1 = "(" + s1 + ")";
                            if ((A[i + 1].OpCode > 1) || (s2.ToArray()[0] == '-'))
                                s2 = "(" + s2 + ")";
                            B[i].Eq = s1 + "*" + s2;
                            res += Num_2(B, val, i);
                        }
                        if (A[i + 1].OpCode != 2)
                        {
                            //add
                            B[i].X = BigInteger.Add(BigInteger.Multiply(A[i].X, A[i + 1].Y),
                                BigInteger.Multiply(A[i].Y, A[i + 1].X));
                            B[i].Y = BigInteger.Multiply(A[i].Y, A[i + 1].Y);
                            B[i].OpCode = 2;
                            string s1 = A[i].Eq;
                            string s2 = A[i + 1].Eq;
                            if (s2.ToArray()[0] == '-')
                                s2 = "(" + s2 + ")";
                            B[i].Eq = s1 + "+" + s2;
                            res += Num_2(B, val, i);
                            //sub -abs
                            B[i].X = 
                                BigInteger.Subtract(BigInteger.Multiply(A[i].X, A[i + 1].Y),
                                BigInteger.Multiply(A[i].Y, A[i + 1].X));
                            bool neg = B[i].X < BigInteger.Zero;
                            if (neg) B[i].X = BigInteger.Abs(B[i].X);
                            B[i].Y = BigInteger.Multiply(A[i].Y, A[i + 1].Y);
                            B[i].OpCode = 2;
                            s1 = A[i].Eq;
                            s2 = A[i + 1].Eq;
                            if (A[i].OpCode > 1)
                                s1 = "(" + s1 + ")";
                            if ((A[i + 1].OpCode > 1) || (s2.ToArray()[0] == '-'))
                                s2 = "(" + s2 + ")";
                            if (neg)
                                B[i].Eq = "(-" + s1 + ")+" + s2; //?
                            else
                                B[i].Eq = s1 + "-" + s2;
                            res += Num_2(B, val, i);
                        }
                    }

                return res;
            }
        }

        static void Test_2(long val, int range = 9, bool wait = true, long out_lim = 400, long pow_lim = 27)
        {
            Console.WriteLine("Test 2 for [1.." + Convert.ToString(range) + "]");
            F.WriteLine("Test 2 for [1.." + Convert.ToString(range) + "]");
            NumEx[] A = new NumEx[range];
            for (int i = 0; i < range; i++)
                A[i] = new NumEx(i + 1, 1, 0);
            SolCount = 0;
            SolLimit = out_lim;
            PowLimit = pow_lim;
            Console.WriteLine("Max power: " + Convert.ToString(PowLimit) + ", output limit: " 
                + Convert.ToString(SolLimit));
            F.WriteLine("Max power: " + Convert.ToString(PowLimit) + ", output limit: "
                + Convert.ToString(SolLimit));
            string s = "Eq count: " + Convert.ToString(Num_2(A, val));
            Console.WriteLine(s);
            F.WriteLine(s);
            Console.WriteLine("Total solutions count for " + Convert.ToString(val) + ": " 
                + Convert.ToString(SolCount));
            F.WriteLine("Total solutions count for " + Convert.ToString(val) + ": "
                + Convert.ToString(SolCount));
            if (wait) Console.ReadLine();
            else
                Console.WriteLine();
            F.WriteLine();
        }

        static long GhostCount = 0;
        static long GhostLimit = (int)Math.Pow(10, 6);
        static long ShadowCount = 0;
        static long ShadowLimit = (int)Math.Pow(10, 6);
        static long Num_3(NumEx[] A, long val, int pos = -1)
        {
            if (A.Length == 1)
            {
                return 1;
            }
            else
            {
                //Ghosts & Shadows
                for (int i = 0; i < A.Length; i++)
                    if (A[i].X != BigInteger.Zero) 
                    {
                        if ((A[i].X % A[i].Y == 0) && (A[i].X / A[i].Y == new BigInteger(val)))
                    {
                        GhostCount++;
                        if (GhostCount <= GhostLimit)
                        {
                            string s = "";
                            for (int j = 0; j < A.Length; j++)
                            {
                                s += "[" + A[j].Eq + "]";
                                if (j == i)
                                    s += "<-[Ghost]";
                                s += ";";
                            }
                            Console.WriteLine(Convert.ToString(val) + "[Ghost]: " + s);
                                F.WriteLine(Convert.ToString(val) + "[Ghost]: " + s);
                        }
                    }
                    else
                    {
                        bool b1 = A[i].X % new BigInteger(val) == 0;
                        bool b2 = A[i].Y % new BigInteger(val) == 0;
                        if (!(!b1 && !b2))
                        {
                            ShadowCount++;
                            if (ShadowCount <= ShadowLimit)
                            {
                                string s = "";
                                for (int j = 0; j < A.Length; j++)
                                {
                                    s += "[" + A[j].Eq + "]";
                                    if (j == i)
                                        s += "<-[Shadow]";
                                    s += ";";
                                }
                                Console.WriteLine(Convert.ToString(val) + "[Shadow]: " + s);
                                    F.WriteLine(Convert.ToString(val) + "[Shadow]: " + s);
                            }
                        }
                    }
                }
                //Main search
                long res = 0;
                for (int i = 0; i < A.Length - 1; i++)
                    if ((A[i + 1].OpCode != 0) || (pos == -1) || (pos >= i))
                    {
                        NumEx[] B = new NumEx[A.Length - 1];
                        for (int j = 0; j < i; j++)
                            B[j] = A[j];
                        for (int j = i + 1; j < A.Length - 1; j++)
                            B[j] = A[j + 1];

                        if ((A[i].OpCode < 2) && (A[i + 1].OpCode == 0))
                        {
                            // concat
                            int p = A[i + 1].X.ToString().Length;
                            B[i].X = BigInteger.Add(A[i + 1].X, BigInteger.Multiply(A[i].X,
                                BigInteger.Pow(new BigInteger(10), p)));
                            B[i].Y = 1;
                            B[i].OpCode = 1;
                            B[i].Eq = A[i].Eq + A[i + 1].Eq;
                            res += Num_3(B, val, i);
                        }

                        if ((A[i + 1].X % A[i + 1].Y) == 0)
                        {
                            //pow
                            BigInteger pow = BigInteger.Divide(A[i + 1].X, A[i + 1].Y);
                            if (pow <= PowLimit)
                            {
                                if (pow.IsZero)
                                {
                                    B[i].X = 1;
                                    B[i].Y = 1;
                                    B[i].OpCode = 4;
                                    string s1 = A[i].Eq;
                                    string s2 = A[i + 1].Eq;
                                    if (A[i].OpCode > 1)
                                        s1 = "(" + s1 + ")";
                                    if (A[i + 1].OpCode > 1)
                                        s2 = "(" + s2 + ")";
                                    B[i].Eq = s1 + "^" + s2;
                                    res += Num_3(B, val, i);
                                }
                                else
                                {
                                    //^
                                    int p = (int)pow;
                                    BigInteger val1 = BigInteger.Pow(A[i].X, p);
                                    BigInteger val2 = BigInteger.Pow(A[i].Y, p);
                                    B[i].X = val1;
                                    B[i].Y = val2;
                                    B[i].OpCode = 4;
                                    string s1 = A[i].Eq;
                                    string s2 = A[i + 1].Eq;
                                    if (A[i].OpCode > 1)
                                        s1 = "(" + s1 + ")";
                                    if (A[i + 1].OpCode > 1)
                                        s2 = "(" + s2 + ")";
                                    B[i].Eq = s1 + "^" + s2;
                                    res += Num_3(B, val, i);
                                    //^-
                                    if ((!val1.IsZero) && (A[i].OpCode != 4))
                                    {
                                        B[i].X = val2;
                                        B[i].Y = val1;
                                        B[i].OpCode = 4;
                                        s1 = A[i].Eq;
                                        s2 = A[i + 1].Eq;
                                        if (A[i].OpCode > 1)
                                            s1 = "(" + s1 + ")";
                                        if (A[i + 1].OpCode > 1)
                                            s2 = "(" + s2 + ")";
                                        B[i].Eq = s1 + "^-" + s2;
                                        res += Num_3(B, val, i);
                                    }
                                }
                            }
                        }
                        if ((A[i + 1].X != 0) && (A[i + 1].OpCode != 3))
                        {
                            //div
                            B[i].X = BigInteger.Multiply(A[i].X, A[i + 1].Y);
                            B[i].Y = BigInteger.Multiply(A[i].Y, A[i + 1].X);
                            B[i].OpCode = 3;
                            string s1 = A[i].Eq;
                            string s2 = A[i + 1].Eq;
                            if (A[i].OpCode > 1)
                                s1 = "(" + s1 + ")";
                            if ((A[i + 1].OpCode > 1) || (s2.ToArray()[0] == '-'))
                                s2 = "(" + s2 + ")";
                            B[i].Eq = s1 + "/" + s2;
                            res += Num_3(B, val, i);
                        }
                        if (A[i + 1].OpCode != 3)
                        {
                            //mul
                            B[i].X = BigInteger.Multiply(A[i].X, A[i + 1].X);
                            B[i].Y = BigInteger.Multiply(A[i].Y, A[i + 1].Y);
                            B[i].OpCode = 3;
                            string s1 = A[i].Eq;
                            string s2 = A[i + 1].Eq;
                            if (A[i].OpCode > 1)
                                s1 = "(" + s1 + ")";
                            if ((A[i + 1].OpCode > 1) || (s2.ToArray()[0] == '-'))
                                s2 = "(" + s2 + ")";
                            B[i].Eq = s1 + "*" + s2;
                            res += Num_3(B, val, i);
                        }
                        if (A[i + 1].OpCode != 2)
                        {
                            //add
                            B[i].X = BigInteger.Add(BigInteger.Multiply(A[i].X, A[i + 1].Y),
                                BigInteger.Multiply(A[i].Y, A[i + 1].X));
                            B[i].Y = BigInteger.Multiply(A[i].Y, A[i + 1].Y);
                            B[i].OpCode = 2;
                            string s1 = A[i].Eq;
                            string s2 = A[i + 1].Eq;
                            if (s2.ToArray()[0] == '-')
                                s2 = "(" + s2 + ")";
                            B[i].Eq = s1 + "+" + s2;
                            res += Num_3(B, val, i);
                            //sub -abs
                            B[i].X =
                                BigInteger.Subtract(BigInteger.Multiply(A[i].X, A[i + 1].Y),
                                BigInteger.Multiply(A[i].Y, A[i + 1].X));
                            bool neg = B[i].X < BigInteger.Zero;
                            if (neg) B[i].X = BigInteger.Abs(B[i].X);
                            B[i].Y = BigInteger.Multiply(A[i].Y, A[i + 1].Y);
                            B[i].OpCode = 2;
                            s1 = A[i].Eq;
                            s2 = A[i + 1].Eq;
                            if (A[i].OpCode > 1)
                                s1 = "(" + s1 + ")";
                            if ((A[i + 1].OpCode > 1) || (s2.ToArray()[0] == '-'))
                                s2 = "(" + s2 + ")";
                            if (neg)
                                B[i].Eq = "(-" + s1 + ")+" + s2; //?
                            else
                                B[i].Eq = s1 + "-" + s2;
                            res += Num_3(B, val, i);
                        }
                    }

                return res;
            }
        }

        static void Test_3(long val, int range = 9, bool wait = true, long out_lim = 1000000, long pow_lim = 27)
        {
            Console.WriteLine("Test 3 for [1.." + Convert.ToString(range) + "]");
            F.WriteLine("Test 3 for [1.." + Convert.ToString(range) + "]");
            NumEx[] A = new NumEx[range];
            for (int i = 0; i < range; i++)
                A[i] = new NumEx(i + 1, 1, 0);
            GhostLimit = out_lim;
            ShadowLimit = out_lim;
            PowLimit = pow_lim;
            Console.WriteLine("Max power: " + Convert.ToString(PowLimit) + ", output limit: "
                + Convert.ToString(SolLimit));
            F.WriteLine("Max power: " + Convert.ToString(PowLimit) + ", output limit: "
                + Convert.ToString(SolLimit));
            string s = "Eq count: " + Convert.ToString(Num_3(A, val));
            Console.WriteLine(s);
            F.WriteLine(s);
            Console.WriteLine("Total ghost count for " + Convert.ToString(val) + ": "
                + Convert.ToString(GhostCount));
            F.WriteLine("Total ghost count for " + Convert.ToString(val) + ": "
                + Convert.ToString(GhostCount));
            Console.WriteLine("Total shadow count for " + Convert.ToString(val) + ": "
                + Convert.ToString(ShadowCount));
            F.WriteLine("Total shadow count for " + Convert.ToString(val) + ": "
                + Convert.ToString(ShadowCount));
            if (wait) Console.ReadLine();
            else
                Console.WriteLine();
            F.WriteLine();
        }

        static StreamWriter F;
        static void Init(string sFilename)
        {
            F = new StreamWriter(sFilename);
        }

        static void Close()
        {
            F.Close();
        }
        static void Main(string[] args)
        {
            Init("Tests_0_-_3.txt");
            for (int i = 2; i <= 9; i++)
            {
                Test_0(i, false);
                Test_1(i, false);
                Test_2(10958, i, false);
                Test_2(10958 / 2, i, false);
                Test_3(10958 / 2, i, false);
            }
            Close();
            while (true)
                Console.ReadLine();
        }
    }
}

निष्कर्ष स्वैच्छिक था, मैं इसके कई खंड दिखाऊंगा:

Test 3 for [1..9]
Max power: 27, output limit: 1000000
5479[Shadow]: [(-((((12^3+4)-5)^-6)^7))+8]<-[Shadow];[9];
5479[Shadow]: [(((12^-3)/4+5)^6+7)-8]<-[Shadow];[9];
5479[Shadow]: [(-(((12^-3)/4+5)^-6+7))+8]<-[Shadow];[9];
5479[Shadow]: [(-(((((12*3)-4)-5)^-6)^7))+8]<-[Shadow];[9];
5479[Shadow]: [(-((((((1^2)/3)^-4)*5)-6)^-7))+8]<-[Shadow];[9];
5479[Shadow]: [(-((((((1^2)*3)^4)*5)-6)^-7))+8]<-[Shadow];[9];
5479[Shadow]: [((-(((-(1^2))+3+4)^-5))+6)^7+8]<-[Shadow];[9];
5479[Shadow]: [(-((((((1^-2)/3)^-4)*5)-6)^-7))+8]<-[Shadow];[9];
5479[Shadow]: [(-((((((1^-2)*3)^4)*5)-6)^-7))+8]<-[Shadow];[9];
5479[Shadow]: [((-(((-(1^-2))+3+4)^-5))+6)^7+8]<-[Shadow];[9];
5479[Shadow]: [(-((((((1/2)^-3)*4)-5)^-6)^7))+8]<-[Shadow];[9];
5479[Shadow]: [((-((((1/2)*3)*4)^-5))+6)^7+8]<-[Shadow];[9];
5479[Shadow]: [(((1/2+3+4)*5)^6+7)-8]<-[Shadow];[9];
5479[Shadow]: [(-(((1/2+3+4)*5)^-6+7))+8]<-[Shadow];[9];
5479[Shadow]: [((((-(1/2))+3)^4+5+6)*7)-8]<-[Shadow];[9];
5479[Shadow]: [(-((((((1*2)^3)*4)-5)^-6)^7))+8]<-[Shadow];[9];
5479[Shadow]: [((-((((1*2)/3)/4)^5))+6)^7+8]<-[Shadow];[9];
5479[Shadow]: [((1*2+3)/4)^5+6+7]<-[Shadow];[8];[9];
5479[Shadow]: [(((1*2+3)/4)^5+6+7)^8]<-[Shadow];[9];
5479[Shadow]: [(((1*2+3)/4)^5+6+7)^-8]<-[Shadow];[9];
5479[Shadow]: [(((1*2+3)/4)^5+6+7)/8]<-[Shadow];[9];
5479[Shadow]: [(((1*2+3)/4)^5+6+7)*8]<-[Shadow];[9];

...

5479[Shadow]: [(-(1/(2*(345-6)+7)))+8]<-[Shadow];[9];
5479[Ghost]: [(-1)+((2*(345-6)+7)*8)]<-[Ghost];[9];
5479[Shadow]: [1/(2-((34^-5)^6)+7)+8]<-[Shadow];[9];

...

Eq count: 957441620
Total ghost count for 5479: 66
Total shadow count for 5479: 10802

भूत पर विचार करें:

$5479 = (-1)+((2*(345-6)+7)*8)$ । प्रारंभिक वेक्टर के सभी तत्वों में, नौ अप्रयुक्त रहता है, लेकिन वेक्टर के ऊपर

$(5479, 9)$ irreducibly 10958. इसी तरह, आपको 65 भूत और 10802 छायाओं को पार्स करने की आवश्यकता है। इंटरनेट पर, कई बड़े गणितीय समुदाय शामिल हैं जो संपूर्ण समस्याओं के "पूर्णता" में शामिल हैं, जैसा कि विमान की टाइलिंग समस्या के मामले में था। हालांकि, जबकि पारस्परिक रूप से सरल आधार और तर्क के साथ लघुगणक की व्युत्पत्ति पर प्रमेय साबित नहीं हुआ है, आगे शोधन का कोई सवाल ही नहीं है। अगले भाग में, हम अधिक विस्तार से अध्ययन करेंगे कि पूर्णांक बीजीय तत्वों के साथ परिमित लंबाई के मनमाना वैक्टर के लिए सभी निष्कर्षों के मशीन गणना का प्रश्न।

असतत विचार

एक पूर्ण असतत प्रतिनिधित्व की अवधारणा

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

तो, गणित से हम जानते हैं कि फार्म के तर्कसंगत संख्याएँ

$a/b$ कहाँ पे

$a$ तथा

$b$ - संख्या के विहित निरूपण में, एक साधारण दशमलव अंश के रूप में एक साथ, साधारण सरल भीलों

$b$ 2 और 5 के अलावा अन्य सभी अपराधों में शून्य डिग्री है, अन्यथा

$a/b$ एक अनंत अंश के रूप में प्रतिनिधित्व किया जा सकता है, जो समय-समय पर होगा

$a/b$ अतार्किक नहीं। तब मशीन समानता की जाँच करें:

${\sqrt 3} = {\sqrt {{\sqrt 12}*{\sqrt {3/4}}}}$ (1)

ऐसा करने के कई तरीके हैं। प्रत्येक विधि अपने स्वयं के डेटा संरचना पर भरोसा करेगी और एक निश्चित दक्षता होगी। यहाँ कुछ विकल्प दिए गए हैं:

हम दो फ्लोटिंग पॉइंट वैरिएबल का उपयोग करते हैं। इस पद्धति का एक स्पष्ट लाभ है: एक कार्यक्रम लिखने पर न्यूनतम समय खर्च किया जाएगा। लेकिन क्रमिक रूप से 12 की जड़ के वास्तविक सन्निकटन की गणना करके, 3/4 की जड़ का वास्तविक सन्निकटन, सटीकता की हानि जब दो वास्तविक और इससे भी अधिक नुकसान की अनुमानित गणना के साथ, हम तीन की जड़ के करीब एक वास्तविक संख्या प्राप्त कर सकते हैं, और संभाव्यता को निर्धारित करने के लिए गणना की पूर्ण त्रुटि का मूल्यांकन कर सकते हैं। समानता की पूर्ति (1)
. . . , , , « ». . :
1. $3 = {\sqrt {\alpha}}$ ; $3 = {\alpha}$ ${\alpha}={\sqrt 3}^2=3$
2. : ${\sqrt {{\sqrt 12}*{\sqrt {3/4}}}}$ ${\alpha}={{\sqrt 12}*{\sqrt {3/4}}}={\sqrt {\beta}}$ ; $\beta$ , : ${\beta}={{\alpha}^2}=9$
3. $12*3$ 4. 0, . $12*3/4=9$ ; , 2 3 : (1) .. $9=9$
, ,
« ». : $a, b, c$ , : ${(a/b)}^{1/c}$ : , . :

$(3,1,2)={\sqrt {{\sqrt {(12,1,1)}}*{\sqrt {(3,4,1)}}}}={\sqrt {(12,1,2)*(3,4,2)}}=$ $={\sqrt {(36,4,2)}}={\sqrt {(9,1,2)}}={\sqrt (3,1,1)}={(3,1,2)}$ ;

इस तरह के एक एल्गोरिथ्म को लागू करने के लिए, ट्रिपल पर संचालन करने के लिए नियमों की एक जटिल प्रणाली का वर्णन करना आवश्यक है $(a,b,c)$ , लेकिन एक तैयार सूचना मॉडल आपको (1) के समान विभिन्न अभिव्यक्तियों की शुद्धता को जल्दी और कुशलता से सत्यापित करने की अनुमति देगा।

"संरचना X" एक डेटा संरचना का एक अच्छा उदाहरण है जो पूर्ण असतत प्रतिनिधित्व है। तर्कहीन और पारलौकिक संख्याओं के असतत प्रतिनिधित्व का सिद्धांत असतत गणित का एक नया क्षेत्र है, जिस पर अधिक ध्यान दिया जाना चाहिए।

परिभाषा: समस्या को हल करने दें

एक परिमित सेट से इनपुट मानों के प्रत्येक वेक्टर के लिए

$M$ ऐसे वैक्टर और कुछ डेटा संरचना के लिए

$Struct_{n_k}$ वेक्टर के प्रत्येक तत्व का एक सेट के रूप में वर्णन करना

$n$ प्राकृतिक संख्या, मोडुलो से अधिक नहीं

$2^{len-1}$ कहाँ पे

$len$ - बिट में कलाकार के मशीन शब्द का आकार, सच:

कलन विधि $Alg$ कार्य को साकार करना $A$ एल की भाषा में सही परिणाम जारी करने के साथ बंद हो जाएगा (आउटपुट प्रारूप के अनुसार, विशिष्ट रूप से व्याख्या की गई और समस्या का समाधान होगा $A$ इनपुट मानों के ऊपर दिए गए वेक्टर)
Alg एल्गोरिथ्म के प्रत्येक चरण के लिए, सभी आरंभिक चर प्रकार के मान $Struct_{n_k}$ (मध्यवर्ती गणनाओं के परिणाम) की स्पष्ट रूप से व्याख्या की जा सकती है, उनका संख्यात्मक मान ठीक से बहाल किया जा सकता है और उपयोग किया जाता है जब सही आउटपुट को बनाए रखते हुए एल्गोरिथ्म को मैन्युअल रूप से ट्रेस किया जाता है।

फिर एक औपचारिक विवरण

$Struct_{n_k}$ कुछ अनिवार्य घोषणात्मक प्रोग्रामिंग भाषा में L को समस्या के समाधान के लिए L के संबंध में L के संबंध में पूर्ण असतत निरूपण (LAP) कहा जाएगा।

$L(A,M, Struct_{n_k})=true$

न्यूनतम आरएपी

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

$Z$ सभी पूर्णांक। वास्तव में: कुछ प्राकृतिक संख्या प्राप्त करने के लिए

$n$ गुना करने के लिए पर्याप्त है

$n$ इकाइयों को प्राप्त करने के लिए

$-n$ का

$n$ आप यूनिक माइनस का उपयोग कर सकते हैं, और गैर-पूर्णांक मानों को घटाया नहीं जाएगा।

परिमित समापन विधि में, हम कई में रुचि रखते हैं

$M_i$ सभी सर्किट तत्व

$M$ अनेक

$A$ संचालन के एक सेट के बारे में

$op$ ऐसा है कि किसी भी मूल्य से उत्पादन करने के लिए

$M_i$ से अधिक नहीं

$i$ से संचालन

$op$ से अधिक परिचालनों में

$A$ । एक निश्चित समस्या को हल करते समय, सभी प्रकार के इनपुट मानों के सेट से

$A$ जिसमें समस्या को हल करने के लिए एल्गोरिथ्म सही परिणाम के साथ बंद हो जाता है जैसे कि जब इस एल्गोरिथ्म को इनमें से किसी भी सेट पर निष्पादित किया जाता है, तो सभी मध्यवर्ती मान (एल्गोरिथम के कुछ चरण में आरंभ किए गए चर के मान) में निहित होंगे

$M_i$ । तब यह साबित हो जाता है कि एक MAP मौजूद है जिसमें कोई अधिक नहीं है

$P$ लंबाई 2 के एक मशीन शब्द के लिए पूर्णांक, जहां

$P$ सेट की बुलंदियों की ताकत है

$M_i$

तनेझी समस्या के लिए, बंद होने के लिए बड़े आकार के कारण परिमित बंद विधि लागू नहीं होती है

$M_9$ 1 से 9 तक अंकों के प्रारंभिक सेट पर सात ऑपरेशन के बारे में। इसलिए, प्रश्न संख्या n को कम करने के लिए उठता है - पूर्णांक चर की संख्या जो एक एल्गोरिथ्म में मध्यवर्ती मूल्यों के वेक्टर के तत्व का वर्णन करती है जो आरोही क्रम में तनेझी समस्या के समाधान को लागू करती है।

परिभाषा: चलो

$L_x$ - कई पूर्ण असतत प्रतिनिधित्व

$\{ L(A,M, Struct_{n_k})\}$ और कुछ तत्व के लिए

$L_{i}(A,M, Struct_{n_{i,k}})$ (मैं सेट के तत्व की अनुक्रम संख्या है) सत्य है:

$\forall j\neq i: L_{j}(A,M, Struct_{n_{j,k}})=true \Rightarrow n_{i,k}\leqslant n_{j,k}$

तब हम तत्व को बुलाएंगे

$\{ L_{i}(A,M, Struct_{n_{i,k}})\}$ समस्या के समाधान के लिए L के संबंध में L के संबंध में न्यूनतम पूर्ण असतत प्रतिनिधित्व (LDP न्यूनतम) A, M के इनपुट मानों के वैक्टर के सेट पर एक और निरूपित करता है:

$L^{(min)}{(A,M, Struct_{n_k})=true}$

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

$(1, 2, ... , 9)$ । आरोही क्रम में तनेज़ी समस्या के लिए न्यूनतम डीएपी का निर्माण संख्या 10958 के लिए एक निष्कर्ष की अनुपस्थिति साबित करने में एक महत्वपूर्ण चरण है।

नई ट्रांसेंडेंटोलॉजी

बेशक, ट्रान्सेंडैंटल और बिल्कुल ट्रान्सेंडैंटल संख्या

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

जब समस्या की स्थितियों के कारण अनिवार्य रूप से प्रोग्राम लिखना है, तो संख्याओं की गणना करना चाहिए

$\pi$ तथा

$e$ ऑपरेंड्स की गुणवत्ता के लिए, वे आम तौर पर या तो उनके अनुमानित प्रतिनिधित्व तक सीमित होते हैं, या श्रृंखला के विश्लेषणात्मक गणना के कार्यक्रम की कोशिश करते हैं जो कि अभिसरण करते हैं

$\pi$ तथा

$e$ क्रमशः। यदि प्रोग्राम के अंतिम परिणाम और गणना की बारीकियों को आउटपुट करने का प्रारूप प्रतीकों के रूप में इस तरह की संख्याओं के उपयोग की अनुमति देता है, तो अनिवार्य रूप से ट्रान्सेंडैंटल घटक की उपस्थिति आरएपी में विशेषता के एक चर के रूप में कम से कम हो जाती है। दो डेटा संरचनाओं और उन संख्याओं की तुलना करें, जिनका वे प्रतिनिधित्व करते हैं और प्रत्येक ऐसी संरचना पर एक निश्चित अमूर्त समस्या को हल करने की अनुकूलता का मूल्यांकन करते हैं:

$(a, b) = a/b$
$(a, b, b_p, c, c_p, d) = {(a+b*{\pi}^{b_p}+c*e^{c_p})}/d$

जाहिर है, ट्रान्सेंडैंटल नंबरों के मामले में न्यूनतम पीडीएल एक अनिवार्य घोषणात्मक भाषा में एल्गोरिदम के कुछ कार्यान्वयन के लिए समय जटिलता के मामले में इष्टतम पीडीएल नहीं हो सकता है।

परिभाषा: चलो

$a_1, a_2$ - कुछ वास्तविक बीजीय संख्याएं (जरूरी नहीं कि अलग हों) और कुछ पारलौकिक वास्तविक संख्याओं के लिए

$\tau$ एक infix प्रतिनिधित्व है:

$\tau = a_1 op a_2$ कहाँ पे

$op$ - सेट से बाइनरी ऑपरेटर: इसके अलावा, घटाव, गुणा, भाग, घातांक। फिर संख्या

$\tau$ 1-पारलौकिक और निरूपित कहा जाएगा

$qtrans({\tau})=1$

परिभाषा: चलो

$a$ कुछ वास्तविक बीजगणितीय संख्या है,

${\tau}_{k}$ के-ट्रान्सेंडैंटल नंबर है, तो हम कुछ नंबर पर कॉल करेंगे

$\tau$ (k + 1) -अंतराल और निरूपित

$qtrans({\tau})=k+1$ यदि यह 1-ट्रान्सेंडैंटल, 2-ट्रान्सेंडैंटल नहीं है ... k- ट्रान्सेंडैंटल और एक infix प्रतिनिधित्व है

${\tau}={\tau}_k op a$ कहाँ पे

$op$ - सेट से बाइनरी ऑपरेटर: इसके अलावा, घटाव, गुणा, भाग, घातांक।

परिभाषा: संख्या

$\tau$ कहा जाएगा परिमित ट्रान्सेंडैंटल और निरूपित

$qtrans({\tau})\neq inf$ अगर कुछ प्राकृतिक संख्या के लिए

$n$ निष्पक्ष:

$qtrans({\tau})=n$

परिभाषा: संख्या

$\tau$ सटीक-पारलौकिक और निरूपित कहा जाएगा

$qtrans({\tau})= inf$ यदि यह वैध है, तो पारलौकिक और परिमित नहीं है।

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

$A$ बीजगणितीय संख्याओं से युक्त इनपुट वैल्यू वैक्टर, जैसे कि किसी भी समस्या के लिए

$A$ एल्गोरिथ्म के संचालन के दौरान आरएपी तत्व के मध्यवर्ती या आउटपुट मूल्यों में से कोई भी इस समस्या के समाधान को लागू नहीं करता है

$A$ इस एल्गोरिथ्म के सभी कार्यान्वयनों के बीच कुछ अनिवार्य घोषणात्मक भाषा में सटीक रूप से पारलौकिक नहीं है

$L$ आरएपी न्यूनतम के साथ कार्यान्वयन में कम से कम समय की जटिलता होगी। ऐसी समस्याओं के सेट ए की शक्ति सीधे आदेश पर निर्भर करती है

$qtrans$ ।

ताऊ भाव

अतः, ट्रान्सेंडैंटल नंबरों के सेट में, कोई 3 डिसऑइंट (कंस्ट्रक्शन) सब्स्क्राइब में अंतर कर सकता है, जिसमें से संघ सभी ट्रान्सेंडैंटल नंबरों के सेट के साथ मेल खाएगा:

परिमित संख्याएँ
सटीक पारलौकिक संख्या
जटिल पारलौकिक संख्या

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

${\pi}$ तथा

$e$ , Gelfond में परिमेय संख्याओं के दशमलव लघुगणक भी शामिल होंगे जो 10 की पूर्ण पूर्णांक शक्तियाँ और कुछ अन्य मान जो व्यावहारिक दृष्टिकोण से महत्वपूर्ण नहीं हैं) शामिल होंगे। वर्तमान खंड में, संख्याओं के एक सेट पर विचार करने का प्रस्ताव है, जिसमें परिमित-पारलौकिक और बिल्कुल पारलौकिक संख्या दोनों शामिल हैं और पूर्ण असतत निरूपण के सिद्धांत के लिए कुछ गुण महत्वपूर्ण हैं। यह एक अनंत संख्या के बारे में है

${\tau}$ -expressions (पढ़ें: ताऊ-अभिव्यक्तियाँ), साथ ही इसके कुछ गणनीय सबसेट।

परिभाषा:

$\tau$ -पहले क्रम के (पढ़ें: ताऊ-रूप) को एक फ़ंक्शन कहा जाएगा

${\tau}_1 ({\alpha})$ किसी भी तर्क के लिए परिभाषित

$\alpha \in \{0, 1\}$ और मूल्यों की तालिका द्वारा दिया गया:

${\tau}_1 (0) = e; {\tau}_1 (1) = \pi$ । पदनाम:

$qtrang({\tau}_1 ({\alpha})) = 1$

परिभाषा:

$\tau$ आदेश का रूप

$n$ हम फ़ंक्शन को कॉल करेंगे

${\tau}_n ({\alpha}_1, {\alpha}_2, ... , {\alpha}_n)$ हर वेक्टर के लिए परिभाषित

$({\alpha}_1, {\alpha}_2, ... , {\alpha}_n)$ कहाँ पे

${\alpha}_i \in \{0, 1\}, i=\overline{\rm 1, n}$ समानता में से एक द्वारा दिया गया:

${\tau}_n ({\alpha}_1, {\alpha}_2, ... , {\alpha}_n) = {\tau}_L ({\alpha}_1, {\alpha}_2, ... , {\alpha}_{k}) + {\tau}_{RA} ({\alpha}_{k+1}, {\alpha}_{k+2}, ... ,{\alpha}_n)$
${\tau}_n ({\alpha}_1, {\alpha}_2, ... , {\alpha}_n) = {{\tau}_1 ({\alpha}_1)} ^ {{\tau}_R ({\alpha}_2, {\alpha}_3, ... , {\alpha}_{n})}$

कहाँ पे

${\tau}_1 ({\alpha})$ -

$\tau$ प्रथम-क्रम रूप

${\tau}_L ({\alpha}_1, {\alpha}_2, ... , {\alpha}_{k})$ -

$\tau$ आदेश का रूप

$k$ बाएं प्रमुख कहा जाता है

$\tau$ रूपों

${\tau}_n ({\alpha}_1, {\alpha}_2, ... , {\alpha}_n)$ ,

${\tau}_R ({\alpha}_2, {\alpha}_3, ... , {\alpha}_n)$ -

$\tau$ आदेश का रूप

$n-1$ सही प्रमुख कहा जाता है

$\tau$ रूपों

${\tau}_n ({\alpha}_1, {\alpha}_2, ... , {\alpha}_n)$ ,

${\tau}_{RA} ({\alpha}_{k+1}, {\alpha}_{k+2}, ... , {\alpha}_n)$ -

$\tau$ आदेश का रूप

$n-k$ सही पूरक कहा जाता है

$\tau$ रूपों

${\tau}_n ({\alpha}_1, {\alpha}_2, ... , {\alpha}_n)$ । पदनाम:

$qtrang({\tau}_n ({\alpha}_1, {\alpha}_2, ... , {\alpha}_n))=n, Lmaj({\tau}_n ({\alpha}_1, {\alpha}_2, ... , {\alpha}_n))={\tau}_L ({\alpha}_1, {\alpha}_2, ... , {\alpha}_{k}),$

$Rmaj({\tau}_n ({\alpha}_1, {\alpha}_2, ... , {\alpha}_n))={\tau}_R ({\alpha}_2, {\alpha}_3, ... , {\alpha}_n)$ ,

$Radd({\tau}_n ({\alpha}_1, {\alpha}_2, ... , {\alpha}_n))={\tau}_{RA} ({\alpha}_{k+1}, {\alpha}_{k+2}, ... , {\alpha}_n)$ ।

के लिये

$\tau$ रूपों

${\tau}_n ({\alpha}_1, {\alpha}_2, ... , {\alpha}_n)$ दिया हुआ

$\tau$ एक प्रथम-क्रम रूप और एक सही प्रमुख या बाएँ प्रमुख और एक सही पूरक माना जाएगा, क्रमशः, बाएँ प्रमुख और सही पूरक या सही प्रमुख अपरिभाषित हैं।

परिभाषा:

$\tau$ -आदेश की अभिव्यक्ति

$n$ हम मूल्य कहेंगे

$\tau$ रूपों

${\tau}_n({\alpha}_1, {\alpha}_2, ... , {\alpha}_n)$ कुछ वेक्टर पर आदेश n

$({a}_1, {a}_2, ... , {a}_n)$ जिसे ड्राइविंग वेक्टर कहा जाता है

$\tau$ -वह जहां

${a}_i \in \{0, 1\}, i=\overline{\rm 1, n}$ ।

हम दाएं और बाएं प्रमुख और सही पूरक की अवधारणाओं को भी परिभाषित करते हैं

$\tau$ -एक्सप्रेसेंस, क्रमशः दाएं और बाएं प्रमुख और सही पूरक के अर्थ के रूप में

$\tau$ रूपों

${\tau}_n({\alpha}_1, {\alpha}_2, ... , {\alpha}_n)$ इस अभिव्यक्ति को परिभाषित करने वाले वेक्टर के संबंधित सब-इंस्पेक्टर पर परिभाषित करना।

उदाहरण

$\tau$ -expressions:

$\pi + e^e$ ;

$e^{e^{\pi}+e}+e^e+e$ ;

${\pi}^{{\pi}^{e+e}}$ ;

परिभाषा: मुख्य शब्द

$\tau$ -expressions

${\tau}_n$ आदेश का

$n$ प्रकार:

${\tau}_n={{\tau}_{1,1}}^{{\tau}_{k_1,1}}+{{\tau}_{1,2}}^{{\tau}_{k_2,2}}+$

$... + {{\tau}_{1,m}}^{{\tau}_{k_m,m}}+{{\tau}_{1,m+1}}+{{\tau}_{1,m+2}}+$

$... + {\tau}_{1,m+p}$ कहाँ पे:

${\tau}_{1, i}$ - कुछ

$\tau$ पहले क्रम के भाव

$i=\overline{\rm 1,m+p}$ ,

${\tau}_{k_j,j}$ - कुछ

$\tau$ -अनुसंधान के आदेश

$k_j$ ,

$j=\overline{\rm 1,m}$
तथा

$n = m+p + k_1 + k_2 + ... + k_m$
हम फॉर्म के तत्वों को कॉल करेंगे:

${\tau}_{1,q}$ तथा

${{\tau}_{1,r}}^{{\tau}_{k_r,r}}$ कहाँ पे

$q=\overline{\rm m+1,m+p}$ ,

$r=\overline{\rm 1,m}$

रिकॉर्ड करने का एक तरीका

$\tau$ -प्रपत्र:

${\tau}({\alpha}_1, {\alpha}_2, {\alpha}_3, {\alpha}_4, {\alpha}_5) = {\tau}_1({\alpha}_1)^{{\tau}_1({\alpha}_2)}+{\tau}_1({\alpha}_3) +{\tau}_1({\alpha}_4) + {\tau}_1({\alpha}_5)$ कहाँ पे

$qtrang({\tau}_1 ({\alpha})) = 1$

बहुत सारे

$\tau$ - परिमित आदेश का विवरण सेट को बंद करने का एक विशेष मामला है

${\pi, e}$ जोड़ और गुणा कार्यों के संबंध में। सबसेट

$\tau$ -एक ही आदेश के संदर्भ हमेशा आदेश दिए जा सकते हैं।

क्रम संख्या का उपयोग करना

$\tau$ पीडीपी के रूप में -expressions आप तुलना करने के लिए अनुमति देता है

$\tau$ -एक्सप्रेस और बिना किसी त्रुटि के उन पर कुछ ऑपरेशन करना, इसके अलावा:

प्रमेय 2. सभी ताऊ भावों के क्रम को एक निश्चित संख्या तक सीमित करके $n$ कई कार्यों के लिए $A$ जिसके लिए RAP ऐसे सभी भावों का प्रतिनिधित्व करती है $L(Alg)$ एक अनिवार्य घोषणात्मक भाषा में $L$ कुछ एल्गोरिथ्म के लिए $Alg$ इस तरह के इनपुट लाइन के लिए - किसी भी अनिवार्य घोषणात्मक भाषा में विवरण $L'$ कुछ कार्य के आरएपी डेटा संरचनाएं $a$ ए से, एल्गोरिथ्म भाषा में स्ट्रिंग - विवरण के आउटपुट के साथ बंद हो जाएगा $L'$ एल्गोरिथ्म के डेटा संरचना के लिए न्यूनतम आरएपी $L(Alg')$ - एल्गोरिथ्म का कार्यान्वयन $Alg'$ समस्या को सुलझाना $a$ भाषा में $L$ ।

आरोही क्रम में तनेझी समस्या को ध्यान में रखते हुए, यह समझना महत्वपूर्ण है कि इनपुट पुनरावृत्ति वेक्टर (1), (2) और (3) के तत्वों में से कोई भी शामिल नहीं है (ऐसे सभी पुनरावृत्तियों को दोहराते हुए साबित होता है)। परिमित पारगमन की परिभाषा से और पूर्वगामी के आधार पर, गैर-कटौती योग्यता इस प्रकार है

$k$ आरोही क्रम में तनेझी समस्या के लिए पारंपरिक मूल्य

$k>6$ । इसलिए, संख्या के लिए एक निष्कर्ष की अनुपस्थिति साबित करने में

$10958$ बस सभी के समर्पण की जाँच करें

$m$ पारलौकिक संख्या

${\tau}_m$ और बीजीय संख्या

$\alpha$ सभी वेक्टर उप-डॉक्टरों पर

$(1, 2, ... , 9)$ ऐसा है कि:

$10958 = {\tau}_m op \alpha, m<6$ कहाँ पे

$op$ ट्रिपल द्वारा दिए गए पुनरावृत्ति (8) के लिए स्वीकार्य के सेट से कुछ ऑपरेशन है

$(op, 1, 2)$ । यह स्थिति पर्याप्त है: अर्थात संख्या का प्रतिनिधित्व करने वाले ऐसे सभी जोड़ो की विरक्ति

$10958$ संख्या की विडंबना को ही सिद्ध करता है

$10958$ , लेकिन आउटपुट से - यह कांसेप्ट सही नहीं है

$m$ -ट्रेनसेंटल मूल समस्या के समाधान का अभी तक पालन नहीं करता है।

सामान्य प्रमेय "ट्रान्सेंडैंटल संख्याओं के परिमित सेट के बंद होने पर"

परिभाषा: हम कॉल करेंगे

$\tau$ -expression

${\tau}_n$ आदेश का

$n$ शर्तों में से एक सच होने पर सामान्य:

${\tau}_n$ एक मान के बराबर संख्यात्मक रूप से: $\pi , e, \pi +e$ तथा $n \in {1, 2}$
$n>2$ और सही प्रमुख ${\tau}_n$ परिभाषित और सामान्य
$n>2$ प्रमुख छोड़ दिया ${\tau}_n$ परिभाषित और सामान्य, सही पूरक ${\tau}_n$ परिभाषित और बाईं मेजर के सामान्य और बीजीय निरूपण ${\tau}_n$ और सही पूरक ${\tau}_n$ समान मुख्य शब्द नहीं हैं।

ध्यान दें कि सामान्यता

$\tau$ -एक्सप्रेसेंस, सरल अर्थों में, इस के बीजीय संकेतन में ऐसे शब्दों की अनुपस्थिति का मतलब है

$\tau$ -expressions।

उदाहरण:

${\pi}^e+e^{\pi}$ - ठीक

$e^{e+{\pi}}+{\pi}+e^{{\pi}+e}$ - सामान्य नहीं है, क्योंकि:

$e^{e+{\pi}}+{\pi}+e^{{\pi}+e} = e^{e+{\pi}}+e^{e+{\pi}}+{\pi} = 2*e^{e+{\pi}}+{\pi}$

परिभाषा:

$\tau$ -expression

${\tau}_0={\tau}_n(a_1, a_2, ... , a_n)$ हम कुछ की जड़ कहेंगे

$\tau$ रूपों

${\tau}_n({\alpha}_1, {\alpha}_2, ... , {\alpha}_n)$ आदेश का

$n$ यदि यह अभिव्यक्ति सामान्य है और असमानता रखती है:

$qtrans({{\tau}_n(a_1, a_2, ... , a_n)}) \leqslant n$ ,
कहाँ

$a_i \in \{0, 1\}, i=\overline{\rm 1, n}$

प्रमेय 3. एक सेट के प्रत्येक गणनीय सबसेट $\tau$ -समित परिमित आदेश में एक परिमित संख्या शामिल है $\tau$ कम से कम एक जड़ होने की सूचना।

आपको याद दिला दूं कि एक गणनीय एक सेट है जिसे सेट के साथ एक-से-एक पत्राचार में रखा जा सकता है

$Q$ पूर्णांकों।

प्रमेय 4. आज्ञा देना $M$ - वास्तविक संख्या का एक निश्चित सेट निम्न स्थितियों को संतुष्ट करता है:

$M$ बेशक या अनगिनत
$M$ कम से कम एक बिल्कुल पारलौकिक तत्व होता है
सर्किट $\overline{\rm M}$ अनेक $M$ द्विआधारी संचालन के एक सेट के बारे में: इसके अलावा और प्रतिपादक नित्य है

तब सेट का प्रत्येक गणनीय सबसेट $\overline{\rm M}$ परिमित पारगमन तत्वों की एक सीमित संख्या शामिल है।

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

सारांश

तनाज़ी समस्या के परिणाम के रूप में परिमित-पारलौकिक संख्याओं का सिद्धांत और संख्या 10958 की समस्या को हल करने के लिए आवश्यक नए गणितीय उपकरण का एक महत्वपूर्ण उपकरण है, जिसका व्यावहारिक अनुप्रयोग प्रोग्रामिंग में और टोपोलॉजी के लिए एक विज्ञान के रूप में सैद्धांतिक महत्व शायद ही कम करके आंका जा सकता है। तर्कसंगत, बीजीय संख्याओं, जटिल संख्याओं और उनके ऊपर के कार्यों के व्यापक वर्गीकरण का विस्तार से अध्ययन किया गया है, और केवल पारम्परिक संख्याएँ आधुनिक गणितज्ञों के लिए एक रहस्य बनी हुई हैं। मनमानी जड़ों के लिए खोजें

$\tau$ समय के साथ एक अभ्यास के रूप में रूपों को वास्तविक संख्याओं के वर्गीकरण की समस्याओं को हल करने के लिए एक नया दृष्टिकोण विकसित करने में मदद मिलेगी।

तनेज़ी समस्या अपने आप में पूर्ण असतत प्रतिनिधित्व की समस्या को प्रकट करती है और पीसी पर गणितीय समस्याओं को हल करते समय डेटा संरचना का वर्णन करने के लिए लोकप्रिय तरीकों की असंगति को दर्शाती है। इसलिए, एक वेक्टर पर तनेझी समस्या के सभी निष्कर्षों की पूरी गणना के लिए

$(1, 2, ... , 7)$ दो घटकों के साथ कॉम्प्लेक्स प्रकार का उपयोग करते समय गणना की पूर्ण त्रुटि - फ्लोटिंग-पॉइंट नंबर - न केवल एक विशिष्ट पूर्णांक की व्युत्पत्ति के प्रश्न को हल करने की अनुमति देगा, बल्कि एक छोटे अंतराल से कम से कम एक पूर्णांक / रागा संख्या की व्युत्पत्ति के प्रश्न को भी हल करेगा।

संख्या १० ९ ५ examination की समस्या की एक सतही परीक्षा में, गणितज्ञों को लोकप्रिय बनाने के लेखों ने केवल "खगोलीय संख्याओं" की समस्या को नोट किया - यह संख्याओं का नाम है (सबसे अधिक बार पूर्णांक) जिसका दशमलव अंकन असंभव है। ज्वलंत उदाहरण - संख्या

$6^{7^{8^9}}$ कि वेक्टर पर लेट गया

$(1, 2, ... , 9)$ या रेटिंग

$N\approx 10^{10^{10^{34}}}$ primes के वितरण पर Chebyshev कानून में एक नकारात्मक त्रुटि की उपस्थिति। वास्तव में, आउटपुट की गणना करने में मध्यवर्ती मूल्य न केवल खगोलीय संख्याएं हो सकते हैं, बल्कि जटिल और ट्रान्सेंडैंटल संख्याएं भी हो सकती हैं, जिनके साथ अंकगणितीय संचालन का कार्यान्वयन और गणना त्रुटियों की गणना मुश्किल है।

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

तनेज़ी का कार्य: गणित के विकास में एक नया चरण?

परिचय

चुनौती इंदर तनेज़ी

सामान्य जानकारी

सटीक शब्दांकन और पहले सामान्यीकरण

निर्णय की प्रगति

भूत और छाया

असतत विचार

एक पूर्ण असतत प्रतिनिधित्व की अवधारणा

न्यूनतम आरएपी

नई ट्रांसेंडेंटोलॉजी

बेशक, ट्रान्सेंडैंटल और बिल्कुल ट्रान्सेंडैंटल संख्या

ताऊ भाव

सामान्य प्रमेय "ट्रान्सेंडैंटल संख्याओं के परिमित सेट के बंद होने पर"

सारांश

संदर्भ

More articles: