🧥 👨🏽‍🚒 🧦 مهمة تانيزي: مرحلة جديدة في تطور الرياضيات؟ 🧖🏻 💥 🖐️

المقدمة

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

حول مشكلة التوائم البسيطة ، على فرضية ABC ، مشكلة Goldbach-Vinogradov وبعض المشاكل الرياضية الهامة الأخرى ، يتم نشر منشورات علمية شعبية جديدة يوميًا. من ناحية ، صمدت هذه المهام في اختبار الزمن ، ومن ناحية أخرى ، يتم دعم العلاقات العامة المنتظمة بمكافآت من ستة أرقام لكل منها. لكن منذ 4 سنوات ، في أعمال عالم رياضيات برازيلي ، أثيرت مشكلة ، بشكل غير مباشر وغير محسوس ، يمكن أن تصبح هدفًا ومعنى الحياة للرياضيين في هذا القرن. نحن نتحدث عن تصنيف الأعداد التجاوزية فيما يتعلق بإغلاق مجموعات محدودة من الأعداد الجبرية.

تحدي اندير تانيزي

معلومات عامة

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

بدأ كل شيء بسلسلة من المنشورات في Reddit ، حيث تحدث Tanezh عن إمكانية تمثيل أي رقم طبيعي أقل من حدود معينة باستخدام عدد محدود من المعاملات. الفكرة نفسها ليست جديدة ، وفي الطبعات السوفيتية للأولمبياد ظهرت مثل هذه الأسئلة بشكل دوري:

تخيل الرقم 1958 باستخدام سبع علامات ، ووضع عوامل الجمع والطرح والضرب والرفع إلى السلطة

الجواب سيكون:

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

أصبح اختيار عرض غير عادي للعام الحالي تقليدًا لأقسام الرياضيات في العديد من الجامعات وأصبح أقوى في الأدب. كان الأمر نفسه مع مشاكل بساطة الأعداد الكبيرة: منذ بضعة قرون ، كانت أرقام Mersenne و Fermat مشغولة بدافع الاهتمام الرياضي ، والآن توفر الأولى التشفير بمفاتيح خاصة موثوقة. وقبل 4 سنوات ، ظهر منشور ينظر فيه إلى الطرق الممكنة لحل مشكلة تمثيل الرقم الطبيعي باستخدام رقم واحد ، وكذلك التمثيلات المنظمة مع جميع الأرقام باستثناء الصفر. على سبيل المثال:

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

من بين العمليات المسموح بها في البداية:

سلسلة: 2 || 3 = 23
إضافة: 2 + 3 = 5
الطرح: 2-3 = -1
الضرب: 2 * 3 = 6
أحادي ناقص: - (2 + 3) = - 5

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

بعد عام ، خرج العمل الضخم بجدول لتمثيل الأرقام من 1 إلى 11 111 باستخدام الأرقام بترتيب تصاعدي وتنازلي. تبين أن مجموعة العمليات المشار إليها أعلاه كافية لتمثيل جميع الأرقام بالأرقام بترتيب تنازلي ، وكذلك لتمثيل 11 110 رقمًا من القائمة بترتيب تصاعدي.

بحثًا عن الموافقة ، يرسل Inder عمله مع التعليقات الشخصية إلى علماء الرياضيات المحترفين وترويج المدونين. من بين المستلمين الآخرين مات باركر - وجه المشروع الأسترالي "الوقوف الرياضي" وأحد المشاركين في مشروع YouTube "Numberphile". أصبح الفيديو حول الرقم الخاص 10958 (الفجوة الوحيدة في جدول تحليلات Tanezh) شائعًا بما يكفي لمحاولات حل المقالات غير الخيالية عن Tanezh تظهر أحيانًا في جميع أنحاء العالم.

جلب جنون الفلكي ومؤلف غير معروف من Yandex.Zen المهمة إلى روسيا. أضاف هذا الأخير أخبارًا عن جائزة بقيمة 5000 دولار أمريكي لإيجاد حل للرقم 10958. ومع ذلك ، لا يعرف موظفو Tanezh أو Parker أو MIT أي شيء عن الجائزة العامة. في غضون ثلاث سنوات ، ظهر عملان الهواة فقط ، مما يجعل على الأقل بعض المحاولات لإيجاد حلول. تم نشر الأول من قبل مشارك سابق في مشروع TedX ويتعلق بمسألة تقييم العدد الإجمالي للتعبيرات المحسوبة التي تم إنشاؤها وفقًا لقواعد Tanezh ووقت تشغيل الخوارزمية الشاملة. والثاني يهدف إلى "توسع ضعيف" للمهمة وهي:

تمثيل جميع الأرقام من 1 إلى 11 111 111 باستخدام الأرقام بترتيب تصاعدي (يمكن استخدام رقم واحد مرة واحدة ويجب استخدام كل رقم) ، وترتيب عوامل التشغيل: أ) ثنائي: الجمع والطرح والضرب والقسمة والأسي ؛ ب) أحادي: ناقص أحادي ، عاملي ، جذر تربيعي

هذا الضعف ، وفقا لمؤلف الدراسة ، كان كافيا لتمثيل 11 111105 أرقام. تقرير الفيديو الأصلي:

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

الصياغة الدقيقة والتعميمات الأولى

أدت صياغة المؤلف الحرة للمشكلة إلى ظهور العديد من القرارات الخاطئة بناءً على تفسير غير صحيح للحالة. الأخطاء الأكثر شيوعًا:

استخدام التسلسل "الخارجي": يُسمح بتجميع عوامل التشغيل الجديدة من أرقام الناقل الأولي ، ولكن يُسمح بالسلسلة بشكل عام حيث يُلحق رقم واحد بحق آخر. أمثلة: $2||3=23$ - يستطيع، $(1+2)||3=33$ - إنه مستحيل
التقريب: حل مشكلة Tanezhi بالأعداد الصحيحة لا يعني فقط استخدام المتجه الأولي الصحيح ، ولكن أيضًا الحصول على نتيجة صحيحة عند الإخراج. أمثلة: $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$ - إنه مستحيل

دعونا نصف عملية التحقق وصنع القرار لمشكلة Tanezhi لعدد معين. دع بعض ناقلات الأرقام المعقدة (في الحالة العامة)

$(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$ هناك حل لمشكلة Tanezhi بترتيب تصاعدي إذا كان هناك تسلسل (والذي سوف نسميه الاشتقاق للرقم أ):

$(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) المحول إذا كان ناتجًا عن إجراء واحدة من ست عمليات حسابية ثنائية بأرقام من 2 إلى 7 ، في أحد التكرارات التي تسبق هذا.

لكل متجه ، عدد العمليات وإمكانية اختيار أزواج من القيم

$(ind, ind+1)$ محدود ، عدد التكرارات التي تسبق استلام النتيجة - الرقم أ - محدود أيضًا. وبالتالي ، هناك عدد محدود من الأعداد الصحيحة التي لها مشكلة Tanezhi في ترتيب تصاعدي لها حل. من الممكن أيضًا أن نظهر من خلال الأمثلة أن تسلسل التكرارات المختلفة لا يؤدي دائمًا إلى نتائج مختلفة ، وكذلك أنه ليس لكل هذه التسلسلات نتيجة كاملة أو على الأقل نتيجة حقيقية. بالإضافة إلى ذلك ، تشير الإحصاءات ، على وجه الخصوص ، إلى نتائج عمل Bill Ams ، إلى أن عدد القيم العقلانية للناتج المختلفة لا يمكن أن يتجاوز ضعف عدد القيم الصحيحة المختلفة. لذلك ، فإن أول تعميم مهم لمشكلة تانيزي هو مجموعة الأسئلة التالية:

كم عدد الاستنتاجات المختلفة التي لها نتيجة صحيحة موجودة؟
كم عدد الأعداد الصحيحة modulo الإخراج؟
كم عدد القيم المعقدة المختلفة المعروضة؟
هل صحيح أن عدد القيم العقلانية المختلفة المستنبطة والمعيارية التي لا تتجاوز بعض الأعداد الصحيحة k لا يتجاوز ضعف عدد الأعداد الصحيحة المستنتجة المعيارية التي لا تتجاوز k؟ لأي ك؟ هل هذا صحيح بشكل عام؟

صحيح أيضًا أنه عند اشتقاق قيمة صحيحة ، بحيث في بعض التكرارات الوسيطة ، يحتوي الناقل على قيم غير منطقية ومعقدة ، ينخفض احتمال الحصول على قيم إجمالية مختلفة ، نظرًا لأن عددًا من العمليات (إضافة غير منطقي إلى العقلاني ، ورفع العقلانية إلى الدرجة غير العقلانية) لا تعود بنتيجة عقلانية ، ولكن بسبب انخفاض عدد الخيارات. لذلك ، ينشأ تعميم آخر:

لإثبات أو دحض ذلك لأي عدد صحيح ، يكون صحيحًا: إذا لم يكن لمشكلة Tanezhi بترتيب تصاعدي للحل حل يتم فيه تنفيذ جميع عمليات التكرار على المتجهات التي لا تحتوي على عناصر غير منطقية ، فلا يوجد حل لها على الإطلاق.

تقدم القرار

أولاً ، ننفذ وظيفة حساب عدد جميع الاستنتاجات التي يمكن اعتبارها حلولًا لبعض - ليس بالضرورة الكل (أي جميع الاستنتاجات التي يتم تنفيذ العملية باستخدام الرمز 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 مليار خيار. عن طريق البناء ، لن تنتج العديد من خيارات الإخراج نفس القيمة فحسب ، بل سيكون لها أيضًا نفس تمثيل infix (احصل على الرقم المطلوب ، باستخدام نفس العوامل ، على نفس المعاملات ، ولكن بترتيب مختلف). على سبيل المثال ، إذا حول التكرار الأول العناصر

$1$ و

$2$ في

$1+2=3$ والعناصر الثانية

$3$ و

$3$ في

$3+3=6$ وإذا قام التكرار الأول بتحويل العناصر

$2$ و

$3$ في

$2+3=5$ والعناصر الثانية

$1$ و

$5$ في

$1+5=6$ ، في كلتا الحالتين نحصل على تعبير إنفيكس:

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

لا يضمن تنفيذ عوامل التشغيل التي تأخذ هذه الفئات في الاعتبار عدم وجود التكرار بين تعبيرات infix ، ولكن BOO يسمح لك بتجاهل بعض هذه التكرارات.

لا يتم حساب قيم عناصر المتجهات لبعض الاستنتاجات ، بسبب الحجم المحدود للكلمة الآلية. باستخدام نوع البيانات BigInteger ، سيكون من الممكن حساب بعض هذه القيم. قم بتعريف بنية البيانات للعنصر المتجه. سيكون هناك عددان صحيحان طويلان ، يمثلان البسط والمقام لبعض الأعداد العقلانية. لكل عامل ، نكتب عددًا من الشروط الإضافية لضمان نتيجة منطقية دون تجاوز. بإضافة رموز التشغيل والقيود على فئات قيم قيم المكرر المتكررة إلى نفس البنية ، نحصل على الوظيفة Num_1 ، التي تحسب BOO عدد الاستنتاجات التي لها تمثيلات مختلفة للخلط. من الواضح أنه لن يتم فقدان أي حل ، بمعنى أنه إذا كان هناك عدد معين من الناتج في Num_0 بحد أدنى ،ثم سيكون هناك ناتج واحد على الأقل في 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 بشكل متكرر بمصفوفة طولها 1) ، سوف نتحقق من انقباض الكسر الذي يمثل عنصرًا من هذا الناقل ونقارن نتيجة قسمة البسط على المقام برقم معين. عند إدخال متغير العداد ، نحصل على إجراء ، وستكون نتيجة ذلك عدد مخرجات عدد فال مع الشروط المحددة. للأرقام

$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 لجميع استنتاجات العدد المحسوبة ، والتي انتهت بالحصول على قيمة val.

نتيجة

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. ما هي ميزته؟

أشباح وظلال

لمهمة مشابهة لمشكلة Tanezhi بترتيب تصاعدي ، ولكن مع ناقلات أولية بطول 8 ، مثل

$(1, 2, ... , 8)$ و

$(2, 3, ... , 9)$ عدد الخيارات أقل ، ومع القيم الصحيحة غير المعقدة والمعقدة والطويلة لعناصر المتجهات (1) - (7) ، تتعامل خوارزميات الرياضيات Wolfram المحسنة. لذا ، فمن المعروف بشكل موثوق أنه لا يوجد استنتاج واحد في

$(1, 2, ... , 9)$ ، التي تحتوي على عامل التسلسل أو الجمع أو الطرح في التكرار الثامن ، لا يمكن أن تؤدي إلى القيمة 10958. ما هي الاحتمالات التي يوفرها هذا لمزيد من الحلول؟

الرقم 10958 بسيط. وإذا كان التكرار الأخير للناتج لا يحتوي على الجمع والطرح والتسلسل ، فإن أحد المعاملات في التكرار الثامن سيتم ضمانه ليشمل 5479 إلى حد ما ، باستثناء حالتين:

عندما تكون المعاملات مضاعفات لبعض المتقارن المعقد
عندما يحتوي أحد المعاملات على لوغاريتم يكون قاعدته أو أسه من مضاعفات 5479

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

نظرية 1: دع $\alpha = log_ab$ أين $a$ و $b$ - بسيطة بشكل متبادل. ثم $\alpha$ لا يمكن استنتاجه على ناقل تعسفي $(c_1, c_2, ... , c_n)$ الطول المحدود n ، أين $c_1, c_2, ... , c_n$ - الأعداد الجبرية

أذكر أن العدد الصحيح الجبرية هو أي رقم يوجد به كثير الحدود مع معاملات صحيحة ومعامل رائد وحدة بحيث أن أحد جذور هذا كثير الحدود هو عدد معين.
إذا كان هناك دليل رسمي على هذه النظرية ، يمكن تضييق البحث عن حلول لمشكلة Tanezhi بشكل كبير. إحدى طرق البحث التي تسمح لك بالتحقق من الاستنتاجات التي من المرجح أن تحصل على القيمة المطلوبة تسمى "طريقة الأشباح والظلال" وقد اقترحتها.

التعريف: دعنا نكرر بعض الاستنتاج

$(1, 2, ... , 9)$ أحد عناصر متجه التكرار الناتج يساوي حرف p ، ثم يطلق على تمثيل infix لهذا العنصر شبح p في هذا الإخراج على

$(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)$ لا يمكن اختزاله 10958. وبالمثل ، تحتاج إلى تحليل 65 أشباح و 10802 ظل. على الإنترنت ، هناك العديد من المجتمعات الرياضية الكبيرة المشاركة في "إكمال" المشاكل الشاملة ، كما كان الحال مع مشكلة تبليط الطائرة. ومع ذلك ، في حين لم يتم إثبات النظرية المتعلقة بقابلية اشتقاق اللوغاريتمات ذات القاعدة والحجة المتبادلتين ، فلا يوجد أي سؤال حول مزيد من التحسين. في القسم التالي ، سوف ندرس بمزيد من التفصيل مسألة تعداد الآلة لجميع الاستنتاجات الخاصة بالنواقل التعسفية ذات الطول المحدود مع العناصر الجبرية الصحيحة.

آراء منفصلة

مفهوم التمثيل المنفصل الكامل

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

لذا ، من الرياضيات ، نعرف أن الأرقام العقلانية للنموذج

$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$ الأعداد الطبيعية ، لا تتجاوز modulo

$2^{len-1}$ أين

$len$ - حجم الكلمة الآلية للفنان بالبت ، صحيح:

خوارزمية $Alg$ تحقيق المهمة $A$ في لغة L سيتوقف مع إصدار النتيجة الصحيحة (المقابلة لتنسيق الإخراج ، وتفسيرها بشكل فريد وكونها حل المشكلة $A$ فوق متجه معين لقيم الإدخال)
لكل مرحلة من خوارزمية Alg ، قيم جميع المتغيرات الأولية للنوع $Struct_{n_k}$ (نتائج الحسابات الوسيطة) يمكن تفسيرها بشكل لا لبس فيه ، ويمكن استعادة قيمتها العددية بدقة واستخدامها عند تتبع الخوارزمية يدويًا مع الحفاظ على الناتج الصحيح

ثم وصف رسمي

$Struct_{n_k}$ في بعض لغات البرمجة التقريرية الحتمية ، يُطلق على L التمثيل الكامل المنفصل (LAP) في L لحل المشكلة A عبر مجموعة ناقلات قيم الإدخال M وتدل على:

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

الحد الأدنى RAP

هناك طرق رسمية لبناء هياكل البيانات التي تلبي معايير RAP. أحدها: طريقة الإغلاق المحدودة. يعتبر إغلاق مجموعة فيما يتعلق بمجموعة من العمليات مجموعة من جميع الأرقام التي يمكن الحصول عليها من خلال إجراء عدد محدود من العمليات المسموح بها على عناصر المجموعة الأصلية. على سبيل المثال: لمجموعة محدودة {0 ، 1} ومجموعة من العمليات: الإضافة الثنائية وإغلاق ناقص واحد ستكون مجموعة

$Z$ جميع الأعداد الصحيحة. في الواقع: الحصول على رقم طبيعي

$n$ ما يكفي للطي

$n$ الوحدات المراد تلقيها

$-n$ من

$n$ يمكنك استخدام السالب الأحادي ، ولن يتم استنتاج القيم غير الصحيحة.

في طريقة الإغلاق المحدودة ، نحن مهتمون بالكثير

$M_i$ جميع عناصر الدائرة

$M$ كثير

$A$ بخصوص مجموعة من العمليات

$op$ بحيث إخراج أي قيمة من

$M_i$ ليس أكثر من

$i$ عمليات من

$op$ على المعاملات من

$A$ . دعونا أثناء حل مشكلة معينة ، مجموعة من جميع أنواع مجموعات قيم الإدخال من

$A$ حيث تتوقف خوارزمية حل المشكلة وتكون النتيجة الصحيحة هي أنه عندما يتم تنفيذ هذه الخوارزمية في أي من هذه المجموعات ، فإن جميع القيم المتوسطة (قيم المتغيرات التي تمت تهيئتها في مرحلة ما من الخوارزمية) ستكمن في

$M_i$ . ثم ثبت أن هناك خريطة لا تتكون من أكثر من

$P$ أعداد صحيحة لكلمة آلة طولها 2 ، حيث

$P$ هي قوة بوليان المجموعة

$M_i$

بالنسبة لمشكلة Tanezhi ، فإن طريقة الإغلاق النهائي غير قابلة للتطبيق نظرًا للحجم الكبير لل Bulean للإغلاق

$M_9$ فيما يتعلق بسبع عمليات على المجموعة الأولية من الأرقام من 1 إلى 9. لذلك ، يطرح السؤال تقليل عدد n - عدد المتغيرات الصحيحة التي تصف عنصر متجه القيم المتوسطة في خوارزمية تنفذ حل مشكلة Tanezhi بترتيب تصاعدي.

تعريف: Let

$L_x$ - العديد من التمثيلات المنفصلة الكاملة

$\{ L(A,M, Struct_{n_k})\}$ وبالنسبة لبعض العناصر

$L_{i}(A,M, Struct_{n_{i,k}})$ (i هو رقم تسلسل عنصر المجموعة) صحيح:

$\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}})\}$ الحد الأدنى من التمثيل المنفصل الكامل (الحد الأدنى من LAP) فيما يتعلق بـ L لحل المشكلة A عبر مجموعة ناقلات قيم المدخلات لـ M وتدل على:

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

في الواقع ، تعد مشكلة Tanezhi ، بالشكل الذي يتم تقديمه به في قسم "الصياغة الدقيقة والتعميمات الأولى" ، مشكلة تمثيل منفصلة كاملة ، وهيكل بيانات NumEx المستخدم في Num_2 و Num_3 خوارزميات البحث عن الإخراج هو مثال على بنية البيانات إكمال حتى على ناقل واحد

$(1, 2, ... , 9)$ . يعتبر إنشاء الحد الأدنى من DAP لمشكلة Tanezhi بترتيب تصاعدي مرحلة مهمة في إثبات عدم وجود استنتاج للرقم 10958.

الفلسفة المتعالية الجديدة

بالطبع ، الأعداد المتعالية والمتسامية بالضبط

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

عند كتابة البرامج التي تعزى حتمًا لظروف المشكلة ، يجب إجراء حسابات تحتوي على أرقام

$\pi$ و

$e$ لجودة المعاملات ، عادة ما تكون إما محدودة بسبب تمثيلها التقريبي ، أو يحاولون برمجة الحساب التحليلي للحد للسلسلة التي تتلاقى

$\pi$ و

$e$ على التوالي. إذا كان تنسيق إخراج النتيجة النهائية للبرنامج وتفاصيل الحسابات يسمح باستخدام مثل هذه الأرقام كرموز ، فإن وجود المكون التجاوزي يقع حتمًا في RAP كحد أدنى كمتغير للسمة. قارن بين هيكلي البيانات والأرقام التي يمثلونها وقيِّموا أمثلية حل مشكلة مجردة معينة على كل هيكل من هذا القبيل:

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

من الواضح أن الحد الأدنى من PDL في حالة الأعداد التجاوزية قد لا يكون PDL الأمثل من حيث التعقيد الزمني لبعض تنفيذ الخوارزمية بلغة تعريفية حتمية.

تعريف: دع

$a_1, a_2$ - بعض الأعداد الجبرية الحقيقية (وليس بالضرورة مختلفة) وبعض الأعداد الحقيقية المتسامية

$\tau$ هناك تمثيل infix:

$\tau = a_1 op a_2$ أين

$op$ - عامل ثنائي من المجموعة: الجمع والطرح والضرب والقسمة والأسي. ثم الرقم

$\tau$ سيُسَمَّى 1-متعالٍ ويشار إليه

$qtrans({\tau})=1$

تعريف: دع

$a$ هو عدد جبر حقيقي ،

${\tau}_{k}$ هو رقم متجاوز ، ثم سنستدعي بعض الأرقام

$\tau$ (ك + 1) - متعال ودلالة

$qtrans({\tau})=k+1$ إذا لم يكن 1-متجاوزًا ، 2-متجاوزًا ... k-transcendental وهناك تمثيل infix

${\tau}={\tau}_k op a$ أين

$op$ - عامل ثنائي من المجموعة: الجمع والطرح والضرب والقسمة والأسي.

التعريف: الرقم

$\tau$ سيطلق عليه اسم متعالٍ محدود ومشار إليه

$qtrans({\tau})\neq inf$ إذا كان بالنسبة لعدد طبيعي

$n$ معرض:

$qtrans({\tau})=n$

التعريف: الرقم

$\tau$ سيطلق عليه اسمًا متجاوزًا تمامًا ويشار إليه

$qtrans({\tau})= inf$ إذا كان صحيحا ومتجاوزا وليس متجاوزا محدودا.

مع إدخال مفهوم العدد التجاوزي المحدود ، يصبح من الممكن العمل بالقيم الدقيقة لبعض الأرقام التجاوزية دون استخدام رموزها. بشكل عام ، يُذكر أنه بالنسبة لبعض المجموعات الفرعية من مجموعة الأعداد المتسامية المحدودة ، هناك مجموعات غير فارغة من المشاكل

$A$ أكثر من متجهات قيمة المدخلات تتكون من أرقام جبرية ، مثل أي مشكلة من

$A$ لا شيء من القيم الوسيطة أو الناتجة لعنصر RAP أثناء تشغيل الخوارزمية التي تنفذ حل هذه المشكلة من

$A$ ليس متجاوزًا بالتحديد بين جميع تطبيقات هذه الخوارزمية في بعض لغة الإعلان الحتمية

$L$ تنفيذ مع الحد الأدنى RAP سيكون أقل تعقيد الوقت. تعتمد قوة المجموعة A من هذه المشكلات بشكل مباشر على الترتيب

$qtrans$ .

تعابير تاو

لذلك ، في مجموعة الأعداد التجاوزية ، يمكن للمرء أن يميز في 3 مجموعات فرعية مفككة (عن طريق البناء) ، يتطابق اتحادها مع مجموعة جميع الأعداد التجاوزية ، وهي:

أعداد متعالية محدودة
الأعداد التجاوزية الدقيقة
أعداد متعالية معقدة

وإذا كان من الممكن أن يتم بناء RAP وفقًا لطريقة الإغلاق المحدود ومحاولة التقليل منه ، فبالنسبة إلى المتعالي المحدود (الذي ، بالإضافة إلى القيم الواضحة)

${\pi}$ و

$e$ ، سيشمل Gelfond أيضًا اللوغاريتمات العشرية للأرقام العقلانية التي لا تمثل قوى عددية صحيحة تمامًا 10 وبعض القيم الأخرى المهمة من وجهة نظر عملية). في القسم الحالي ، يُقترح النظر في مجموعة من الأرقام ، بما في ذلك كل من الأعداد المحدودة والمتسامية والأرقام المتسامية بدقة وامتلاك بعض الخصائص المهمة لنظرية التمثيلات المنفصلة الكاملة. حول عدد لا نهائي

${\tau}$ - تعبيرات (اقرأ: تعبيرات تاو) ، بالإضافة إلى بعض مجموعاتها الفرعية المعدودة.

تعريف:

$\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)$ أجل ن على بعض ناقلات

$({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$ -التعبيرات:

$\pi + e^e$ ؛

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

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

التعريف: المصطلحات الرئيسية

$\tau$ -التعبيرات

${\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$ -التعبير عن PDP يسمح لك للمقارنة

$\tau$ -التعبير عن بعض العمليات وتنفيذها دون أي خطأ.

نظرية 2. بتقييد ترتيب جميع تعبيرات تاو إلى عدد معين $n$ للعديد من المهام $A$ حيث يمثل RAP كل هذه التعبيرات ، هناك تنفيذ $L(Alg)$ بلغة تعريفية حتمية $L$ لبعض الخوارزمية $Alg$ مثل ذلك لخط الإدخال - الأوصاف بأي لغة إعلانية حتمية $L'$ هياكل بيانات RAP لبعض المهام $a$ من A ، ستتوقف الخوارزمية مع إخراج السلسلة - أوصاف باللغة $L'$ الحد الأدنى من RAP لبنية البيانات في الخوارزمية $L(Alg')$ - تنفيذ الخوارزمية $Alg'$ حل المشاكل $a$ في اللغة $L$ .

بالنظر إلى مشكلة Tanezhi بترتيب تصاعدي ، من المهم أن نفهم أنه لا يوجد أي عنصر من عناصر متجه تكرار الإدخال (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$ - لا يتبع Transcendental بعد حل المشكلة الأصلية.

النظرية العامة "حول إغلاق مجموعات محدودة من الأعداد التجاوزية"

التعريف: سوف نتصل

$\tau$ -التعبير

${\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$ -التعبيرات.

أمثلة:

${\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$ -التعبير

${\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$ النماذج كتمرين بمرور الوقت ستساعد في تطوير نهج جديد لحل مشاكل تصنيف الأعداد الحقيقية.

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

$(1, 2, ... , 7)$ خطأ الحساب المطلق عند استخدام النوع المركب مع مكونين - أرقام الفاصلة العائمة - لن يسمح بحل مسألة قابلية اشتقاق عدد صحيح معين فقط ، ولكن أيضًا مسألة قابلية اشتقاق عدد صحيح / رقم منطقي واحد على الأقل من فاصل زمني قصير.

في فحص سطحي لمشكلة الرقم 10958 ، أشارت مقالات نشر علماء الرياضيات فقط إلى مشكلة "الأرقام الفلكية" - هذا هو اسم الأرقام (في الغالب الأعداد الصحيحة) التي لا يمكن تدوينها العشري. أمثلة حية - العدد

$6^{7^{8^9}}$ التي تقع فوق الناقل

$(1, 2, ... , 9)$ أو تصنيف

$N\approx 10^{10^{10^{34}}}$ ظهور خطأ سلبي في قانون تشبيشيف حول توزيع الأعداد الأولية. في الواقع ، لا يمكن أن تكون القيم الوسيطة في حساب الناتج أرقامًا فلكية فحسب ، بل أيضًا أرقامًا معقدة ومتعدية ، وتنفيذ العمليات الحسابية التي يصعب معها حساب أخطاء الحساب.

من ناحية ، تُعلم رياضيات العلوم الشعبية أجيالًا جديدة من المزارعين ، مما يؤثر سلبًا على صورة العلوم المهنية. من ناحية أخرى ، يؤدي جذب انتباه جمهور بملايين الدولارات إلى مشاكل رياضية لم يتم حلها إلى ظهور العديد من الآراء البديلة حول الصيغ والحلول الممكنة ، وتشكل بعض هذه الأفكار أساس عمل علماء الرياضيات المحترفين. هكذا كان الأمر مع مهمة Erdös ، وبالتالي فإن عمل هواة Inder Tanega على التمثيلات الرائعة للأعداد الصحيحة يمكن أن يغير الرياضيات الحديثة ويعطي مجال تكنولوجيا المعلومات نهجًا جديدًا لوصف هياكل البيانات.

مهمة تانيزي: مرحلة جديدة في تطور الرياضيات؟

المقدمة

تحدي اندير تانيزي

معلومات عامة

الصياغة الدقيقة والتعميمات الأولى

تقدم القرار

أشباح وظلال

آراء منفصلة

مفهوم التمثيل المنفصل الكامل

الحد الأدنى RAP

الفلسفة المتعالية الجديدة

بالطبع ، الأعداد المتعالية والمتسامية بالضبط

تعابير تاو

النظرية العامة "حول إغلاق مجموعات محدودة من الأعداد التجاوزية"

ملخص

المراجع

More articles: