🥡 💃🏽 🏭 塔内芝的任务：数学发展的新阶段？ 🍊 👂🏽 🍰

介绍

二十一世纪的数学与古代根本不同。这不仅是几何和算术方面的新进展-科学是几千年前形成的基本原理。随着计算机技术的出现，优先级发生了变化，并且“运动发展”领域的数字理论已经成为一门科学，世界经济所依赖的成就。

关于简单双胞胎问题，ABC假设，哥德巴赫-维诺格拉多夫（Goldbach-Vinogradov）问题和其他一些重要的数学问题，每天都会出版新的大众科学出版物。一方面，这些任务经受了时间的考验，另一方面，定期的公关活动得到了每人六位数的奖励。但是4年前，在一位巴西数学家的著作中，一个对他本人的间接和潜移默化的问题提出了，这可能成为本世纪数学家生活的目标和意义。我们正在谈论关于有限数字代数封闭的先验数字的分类。

挑战Inder Tanezhi

一般信息

Inder Tanega是一位在巴西流行的数学家，他一生中大部分时间致力于魔方，三角数和其他娱乐性工作。他从未从事过本世纪未解决的问题，对自然序列的性质的研究没有做出专业贡献，但是在他的业余研究中，提出了现代数学无法回答的问题。

一切始于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

Tanezha认为该部门无用，因为像上面的示例一样，最多可以表示1000个数字，而无需进行其他操作。但是，尽管如此，将来他还是将必要的最低限度提高了度数（包括中间分数计算中出现的分数分数，理性，不合理和复杂指标的分数，并且在计算结束时得出了整个结果）和除法。

一年后，大量工作出现了，数字从1到11111代表表格，使用数字升序和降序。上面指出的一组操作证明足以以降序表示数字中的所有数字，并以升序表示列表中的11110个数字。

为了获得批准，Inder将他的工作连同个人评论邮寄给专业数学家和流行博客。其他获奖者包括Matt Parker，他是澳大利亚项目“数学站立”的代言人，也是YouTube项目“ Numberphile”的参与者之一。有关10958特殊数字的视频（在Tanezh分解表中唯一的空白）变得非常流行，以至于试图解决有关Tanezh的非小说类文章有时出现在世界各地。

疯狂的天文学家和Yandex.Zen的一位不知名作者将这项任务带到了俄罗斯。后者增加了有关找到10958号解决方案的5,000美元奖金的消息。但是，Tanezh，Parker和MIT员工都不知道有关公共奖励的任何信息。在三年中，只有两项业余作品问世，至少进行了一些尝试来寻找解决方案。第一个由TedX项目的前参与者发布，涉及评估根据Tanezh规则构造的可计算表达式的总数以及穷举算法的运行时间的问题。第二个目标是“弱扩展”任务，即：

用升序表示数字（从1到11111111）（一个数字可以使用一次，每个数字必须使用），并安排运算符：a）二进制：加，减，乘，除，乘幂；b）一元：一元减，阶乘，平方根

根据研究的作者，这种减弱足以代表11 111 105个数字。原始视频报告：

尚未尝试以我们需要的形式提供准确的分析证明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$ 如果存在一个序列（我们将其称为数字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)$ 对于运算符的值等于1的每次迭代，确实是带有数字的元素

$ind_m {ind_m}+1$ 不转换。在执行某些迭代时，如果该元素的值是从原始矢量中获取或通过串联原子值而获得的，则我们将称其为某个新的矢量（x）原子的元素。如果在转换向量（y）之前执行的迭代之一中，执行从数字2到7的六个二进制算术运算之一，则将调用转换后的某个新向量（y）的元素。

对于每个向量，运算数量以及选择值对的可能性

$(ind, ind+1)$ 如果有限，则接收结果之前的迭代次数-次数a-也受到限制。因此，存在有限数量的整数，对于这些整数，Tanezhi问题按升序求解。还可以通过示例显示不同的迭代序列并不总是导致不同的结果，而且并非所有此类序列都具有完整或至少真实的结果。此外，统计数据特别是Bill Ams的工作结果表明，不同输出有理值的数量不能超过不同整数值的数量的两倍。因此，Tanezhi问题的第一个重要概括是以下问题：

存在多少个具有整数结果的不同结论？
输出多少个模整数？
显示多少个不同的复数值？
推论和取模不超过某个整数k的不同有理值的数量是否不超过取模不超过k推导不同的整数的数量的两倍是真的吗？对于哪个k？总的来说是真的吗？

的确是这样，当推导整数值时，例如在某些中间迭代中，向量包含不合理和复杂的值，获得不同总值的可能性会降低，因为许多运算（将不合理性添加到有理数，将有理度提高到不合理度）不会返回有理结果，但是因为选项数量减少了。因此，出现了另一种概括：

证明或证明对于任何整数a都是正确的：如果a的升序Tanezhi问题没有解决方案，其中输出的所有迭代都在不具有非理性元素的向量上执行，那么它根本没有解决方案。

决策进度

首先，我们实现了对所有结论的数量进行计数的功能，该结论可以视为某些a的解决方案-不一定是整体（即，仅对原子操作数执行代码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

我们有大约1,120亿份期权。通过构造，许多输出选项不仅会产生相同的值，而且具有相同的中缀表示（使用相同的运算符，相同的操作数，但顺序不同，获得所需的数字）。例如，如果第一次迭代转换了元素

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

考虑到这些类的运算符的实现不能保证中缀表达式之间不存在重复，但是BOO允许您丢弃其中一些重复。

由于机器字的大小有限，某些结论的向量元素的值无法计算。使用BigInteger数据类型，可以计算其中一些值。声明向量元素的数据结构。其中有两个长整数，代表某个有理数的分子和分母。对于每个运算符，我们编写了许多附加条件，以保证没有溢出的合理结果。在相同的结构中添加操作代码和重复中缀值类别的限制，我们获得函数Num_1，BOO计算具有不同中缀表示形式的结论数。显然，在某种意义上说，如果某个数字a至少在Num_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

收到了约47.62亿个表达式。

在vector元素的数据结构中，我们还创建了一个字符串字段，该字段中将累积输出的中缀表示。在迭代链的末尾（当递归调用长度为1的数组的Num_2函数时），我们将检查表示此向量元素的分数的可收缩性，并将分子除以分母后得到的结果与某个数字进行比较。输入计数器变量，我们得到一个过程，其结果将是在给定条件下val的输出数量。对于数字

$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();
        }

输出将包含结论的数量（可以精确计算其结果）以及所计算数量的所有结论的中缀表达式，最后得到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，可以证明约有9.57亿个结论的结果是可计算的，其中356个是数字5479的结论，而不是单个结论（因此不是具有加，减，级联，乘法和除法运算的单个结论，以及具有相同运算和某些整数幂的某些结论）不是数字10958的结论。它的特点是什么？

鬼影

对于与Tanezhi问题相似的任务，但其升序为初始向量，长度为8，例如

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

$(2, 3, ... , 9)$ 选项的数量较少，并且使用向量（1）-（7）的元素的不合理，复杂和长整数值，优化的Wolfram数学算法可以应对。因此，可以肯定的是，在

$(1, 2, ... , 9)$ ，在第8次迭代中具有并置，加法或减法运算符，则不能得出值10958。这对于进一步的解决方案有什么可能性？

数字10958是半简单的。并且，如果输出的最后一次迭代不包含加，减和串联，那么在第八次迭代中的一个操作数将在某种程度上保证包括5479，以下两种情况除外：

当操作数是某些复共轭的倍数时
当其中一个操作数包含以5479的倍数为底或指数的对数时

如果第一种情况在同一Wolfram数学的能力范围内，则第二种情况必须分开考虑。迄今为止，尚未找到任何结论，其中在任何迭代中输出向量的元素都是满足情况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，则此元素的中缀表示将在

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

定义：让某些结论的一些迭代结束

$(1, 2, ... , 9)$ 结果向量的元素之一是有理数，其分子或分母除以质数p，并且该元素不是幻影，则此元素的中缀表示将在此输出中称为数字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$ 自然数，取模不超过

$2^{len-1}$ 哪里

$len$ -艺术家的机器字大小，以位为单位，为true：

算法 $Alg$ 实现任务 $A$ 用L语言编写的语言将以发布正确的结果而停止（对应于输出格式，经过唯一解释并作为问题的解决方案） $A$ 高于输入值的给定向量）
对于Alg算法的每个阶段，所有类型的初始化变量的值 $Struct_{n_k}$ （中间计算的结果）可以得到明确的解释，当手动跟踪算法同时保持正确的输出时，可以准确地恢复和使用其数值

然后是正式的描述

$Struct_{n_k}$ 在某些命令式声明性编程语言中，L相对于L称为完全离散表示（LAP），以解决输入值M的向量集上的问题A并表示：

$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问题，由于buule的尺寸较大，所以不适用有限闭合方法

$M_9$ 关于从1到9的初始数字集上的七个运算。因此，出现了一个问题，即在以升序实现Tanezhi问题解的算法中，最小化数n-描述中间值向量元素的整数变量的数量。

定义：让

$L_x$ -许多完整的离散表示

$\{ L(A,M, Struct_{n_k})\}$ 对于某些元素

$L_{i}(A,M, Struct_{n_{i,k}})$ （i是集合元素的序号）为true：

$\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的最小完整离散表示形式（LAP最小值），用于解决M个输入值向量的集合上的问题A并表示：

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

实际上，以“精确措辞和第一泛化”部分介绍的形式出现的Tanezhi问题是一个完整的离散表示问题，在Num_2和Num_3输出搜索算法中使用的NumEx数据结构是一个数据结构的例子，而不是即使在一个向量上也完整

$(1, 2, ... , 9)$ 。为证明Tanezhi问题的最小DAP（按升序排列）是一个重要的阶段，证明没有数字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。

定义： let

$a_1, a_2$ -一些实数（不一定是不同的）和一些先验实数

$\tau$ 有一个中缀表示：

$\tau = a_1 op a_2$ 哪里

$op$ -集合中的二进制运算符：加法，减法，乘法，除法，求幂。然后号

$\tau$ 将被称为1-超越，并表示为

$qtrans({\tau})=1$

定义： let

$a$ 是一些实数

${\tau}_{k}$ 是一个k超越数，那么我们将称某个数

$\tau$ （k + 1）-先验并表示

$qtrans({\tau})=k+1$ 如果不是1超越，2超越... k超越并且有中缀表示

${\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个不相交的（通过构造）子集，这些子集的并集将与所有先验数字的集合一致，即：

有限的先验数
精确的先验数
复杂的先验数

如果对于有限超越，我们可以根据有限闭合方法构造DAP并尝试将其最小化，那么对于完全超越（除了明显的值，

${\pi}$ 和

$e$ ，Gelfond还将包括有理数的十进制对数，这些有理数不是精确的10的整数次幂，还有一些其他从实用角度来看很重要的值）。在本节中，建议考虑一组数字，包括有限超越数和精确超越数，并且它们具有一些对于完全离散表示的理论很重要的属性。大约是无限个

${\tau}$ -expressions（阅读：tau-expressions）及其一些可计数的子集。

定义：

$\tau$ 一阶的-form（读取：tau-form）将被称为函数

${\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$ -表达式：

$\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$ -expressions as PDP允许您比较

$\tau$ -expressions并对其执行一些操作而没有任何错误，而且：

定理2。通过将所有tau表达式的顺序限制为一定数量 $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的一个重要推论是，仅对代数和有限超越数进行计算的算法存在MAP最小值。定理4给出了有限的先验数在所有实际先验数之间的分布的一般概念，对于作为对包含先验元素的指数的组，环和闭包进行分类的理论工具来说是有价值的。

摘要

作为Tanezhi问题的结果的有限超越理论和解决10958问题所必需的新数学仪器的一部分是一个重要的工具，在编程中的实际应用以及拓扑学作为一门科学的理论意义不容小under。存在对有理数，代数数的综合分类，详细研究了其上方的复数和函数，只有先验数仍然是现代数学家的一个谜。搜索任意根

$\tau$ 表格作为一种随时间的练习，将有助于开发一种新方法来解决实数分类问题。

Tanezhi问题本身揭示了完整离散表示的问题，并显示了在PC上解决数学问题时描述数据结构的流行方法的不一致。因此，对于向量上Tanezhi问题的所有结论的完整枚举

$(1, 2, ... , 7)$ 在将复杂类型与两个组成部分（浮点数）一起使用时的绝对计算错误将不仅解决一个特定整数的可导性问题，而且还不能解决一个短间隔内至少一个整数/有理数的可导性问题。

在普及数学家的文章中对10958的数字问题进行了表面的考察，只注意到了“天文数字”的问题-这是数字的名称（通常是整数），其十进制表示法是不可能的。生动的例子-数字

$6^{7^{8^9}}$ 落在向量上

$(1, 2, ... , 9)$ 或评分

$N\approx 10^{10^{10^{34}}}$ 切比雪夫定律分布中的负误差出现。实际上，计算输出中的中间值不仅可以是天文数，而且可以是复数和先验数，难以执行算术运算和计算误差。

一方面，科普数学教育了新一代的农民，这对专业科学的形象产生了负面影响。另一方面，吸引数百万美元的听众注意未解决的数学问题，引起了对公式和可能的解决方案的许多替代观点，其中一些思想构成了专业数学家工作的基础。Erdös的任务也是如此，因此今天Inder Tanega关于整数的奇妙表示的业余工作可以改变现代数学，并为IT领域提供一种描述数据结构的新方法。

塔内芝的任务：数学发展的新阶段？

介绍

挑战Inder Tanezhi

一般信息

确切的措词和第一泛化

决策进度

鬼影

离散意见

完整离散表示的概念

最低RAP

新先验学

当然，先验数和精确先验数

头表达

一般定理“关于有限数量的超越数”

摘要

参考文献

More articles: