Get best of the week

La tarea de Tanezhi: ¿una nueva etapa en el desarrollo de las matemáticas?

Introducción


Las matemáticas del siglo XXI son fundamentalmente diferentes de las antiguas. Y esto no se trata solo de nuevos avances en geometría y aritmética - ciencias, cuyos principios básicos se formaron hace milenios. Con el advenimiento de la tecnología informática, la prioridad ha cambiado, y la teoría de los números del campo de "ejercicios para el desarrollo de la mente" se ha convertido en una ciencia, de cuyos logros depende la economía mundial.

Sobre el problema de los gemelos simples, sobre la hipótesis ABC, el problema de Goldbach-Vinogradov y algunos otros problemas matemáticos importantes, se publican diariamente nuevas publicaciones científicas populares. Por un lado, estas tareas han resistido la prueba del tiempo, y por otro lado, las relaciones públicas regulares están respaldadas por recompensas de seis cifras para cada una. Pero hace 4 años, en las obras de un matemático brasileño, se planteó un problema, indirecto e imperceptible para sí mismo, que podría convertirse en la meta y el significado de la vida para los matemáticos de este siglo. Estamos hablando de la clasificación de los números trascendentales con respecto al cierre de conjuntos finitos de números algebraicos.

Challenge Inder Tanezhi


Información general


Inder Tanega es un matemático popularizador brasileño que ha dedicado la mayor parte de su vida a cuadrados mágicos, números triangulares y otras tareas entretenidas. Nunca abordó los problemas no resueltos del siglo, no hizo una contribución profesional al estudio de las propiedades de la serie natural, pero fue en sus estudios de aficionados que surgieron preguntas que las matemáticas modernas no pueden responder.

Todo comenzó con una serie de publicaciones en Reddit, donde Tanezh habló sobre la posibilidad de representar cualquier número natural menor que cierto límite usando un número limitado de operandos. La idea en sí no es nueva, y en las ediciones soviéticas para las olimpiadas, tales preguntas surgían periódicamente:
Imagine el número 1958 usando siete deuces, colocando los operadores de suma, resta, multiplicación y elevación a una potencia.

La respuesta será:

1958 = 22 2 ∗ 2 ∗ 2 + 22


La selección de una presentación inusual para el año en curso se ha convertido en una tradición para los departamentos de matemática de muchas universidades y se ha fortalecido en la literatura. Lo mismo sucedió con los problemas de la simplicidad de los grandes números: hace un par de siglos, los números de Mersenne y Fermat estaban comprometidos por interés deportivo, y ahora los primeros proporcionan criptografía con claves privadas confiables. Y hace 4 años, apareció una publicación en la que consideraban posibles formas de resolver el problema de representar un número natural usando un dígito, así como representaciones ordenadas con todos los dígitos excepto cero. Por ejemplo:

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


Entre las operaciones permitidas estaban inicialmente:

  • concatenación: 2 || 3 = 23
  • Además: 2 + 3 = 5
  • resta: 2-3 = -1
  • multiplicación: 2 * 3 = 6
  • menos unario: - (2 + 3) = - 5

Tanezha consideró que la división era inútil, ya que los números de hasta mil podrían representarse como el ejemplo anterior sin operaciones adicionales. Pero en el futuro, sin embargo, agregó al mínimo necesario un aumento de grado (incluidos los grados con indicadores fraccionales racionales, irracionales y complejos, si tales surgieron en los cálculos intermedios y condujeron al resultado completo al final de los cálculos) y la división.

Un año después, salió un voluminoso trabajo con una tabla de representaciones de números del 1 al 11 111 usando números en orden ascendente y descendente. El conjunto de operaciones indicado anteriormente resultó ser suficiente para representar todos los números en dígitos en orden decreciente, así como para representar 11 110 números de la lista en orden creciente.

En busca de aprobación, Inder envía su trabajo con comentarios personales a matemáticos profesionales y bloggers populares. Entre otros destinatarios se encuentra Matt Parker, el rostro del proyecto australiano "Mathematical Stand-up" y uno de los participantes en el proyecto de YouTube "Numberphile". El video sobre el número especial 10958 (el único espacio en la tabla de descomposiciones de Tanezh) se hizo lo suficientemente popular como para que los intentos de resolver y artículos científicos populares sobre Tanezh a veces aparecieran en todo el mundo.


Un astrónomo loco y un autor desconocido de Yandex.Zen llevaron la tarea a Rusia. Este último agregó noticias de un premio de $ 5,000 por encontrar una solución para el número 10958. Sin embargo, ni Tanezh, ni Parker, ni los empleados del MIT saben nada sobre el premio público. En tres años, solo salieron dos trabajos de aficionados, haciendo al menos algunos intentos de encontrar soluciones. El primero fue publicado por un ex participante del proyecto TedX y se refiere a la cuestión de evaluar el número total de expresiones computables construidas de acuerdo con las reglas de Tanezh y el tiempo de ejecución del algoritmo exhaustivo. El segundo está dirigido a la "expansión débil" de la tarea, a saber:

Representar todos los números del 1 al 11 111 111 usando números en orden ascendente (se puede usar un dígito una vez y se debe usar cada dígito), ordenando los operadores: a) binario: suma, resta, multiplicación, división, exponenciación; b) unario: unario menos, factorial, raíz cuadrada

Este debilitamiento, según el autor del estudio, fue suficiente para representar 11 111 105 números. Informe de video original:


No se han realizado intentos para proporcionar pruebas analíticas precisas de la no representabilidad del número 10958 en la forma que necesitamos; en cualquier caso, la información sobre ellos no está disponible en ninguno de los idiomas extranjeros disponibles para mí. La imposibilidad de una solución exhaustiva y las características del número 10958 se describirán con más detalle a continuación.

Redacción exacta y primeras generalizaciones.


La formulación libre del problema por parte del autor dio lugar a muchas decisiones erróneas basadas en una interpretación incorrecta de la condición. Los errores más comunes:

  • El uso de la concatenación "externa": la compilación de nuevos operadores a partir de los dígitos del vector inicial es permisible, pero la concatenación en forma general como la adición de un número a la derecha de otro está prohibida. Ejemplos:2 | El | 3 = 23 - lata, ( 1 + 2 ) | El | 3 = 33 - Es imposible
  • redondeo: resolver el problema de Tanezhi en enteros significa no solo usar un vector inicial entero, sino también obtener un resultado entero en la salida. Ejemplos:8 = ( 1 - 2 + 3 ) ∗ 4 - lata, 7≈(1+2/3)∗4=20/3 - Es imposible
  • El uso de operandos adicionales: al realizar la operación de elevar a una potencia, algunos autores consideran el conjunto inicial de números como bases válidas para el grado y recurren a indicadores arbitrarios. Ejemplos:31=(1+23)∗4−5 - lata, 10958=(1+23)∗3+43+5∗6∗7+84+94 - Es imposible

Describamos el proceso de verificación y toma de decisiones del problema de Tanezhi para un número determinado. Dejemos algún vector de números complejos (en el caso general)(c1,c2,...,ck) propuso tres ( o p , i n d , i n d + 1 )dónde i n d y i n d + 1 - números naturales consecutivos, i n d 1 < = k; o p - código de operador - un número natural del 1 al 7, luego iteración ( o p , i n d , i n d + 1 ) sobre el vector ( C 1 , C 2 , . . .,Ck) llamaremos al proceso, cuyo resultado es un vector de longitud k-1a saber:

  1. vector (C1,C2,...,conyonortere-1,CyonortereEl |El |Cyonortere+1,Cyonortere+2,...,Ck) para opags=1
  2. vector (C1,C2,...,conyonortere-1,Cyonortere+Cyonortere+1,Cyonortere+2,...,Ck) para opags=2
  3. vector (C1,C2,...,conyonortere-1,El |Cyonortere-Cyonortere+1El |,Cyonortere+2,...,Ck) para opags=3
  4. vector (C1,C2,...,conyonortere-1,Cyonortere∗Cyonortere+1,Cyonortere+2,...,Ck) para opags=4 4
  5. vector (C1,C2,...,conyonortere-1,Cyonortere/ /Cyonortere+1,Cyonortere+2,...,Ck) para opags=5 5
  6. vector (C1,C2,...,conyonortere-1,CCyonortere+1yonortere,Cyonortere+2,...,Ck) para opags=6 6
  7. vector (C1,C2,...,conyonortere-1,C-(Cyonortere+1)yonortere,Cyonortere+2,...,Ck) para opags=7 7

Deje que se dé el vector inicial (1,2,...,9 9)de nueve elementos iguales a sus números de serie. Luego dicen que por algún número enterouna hay una solución al problema de Tanezhi en orden ascendente si hay una secuencia (que llamaremos derivación para el número a):

(opags1,yonortere1,yonortere1+1) Es una iteración sobre el vector inicial, cuyo resultado es el vector (1)
(opags2,yonortere2,yonortere2+1)Es una iteración sobre el vector (1), cuyo resultado es el vector (2)
...
(opags8,yonortere8,yonortere8+1)Es una iteración sobre el vector (7), cuyo resultado es el vector (8), de

modo que el vector (8) es igual al vector(una) cualquier vector (-una) y para cada iteración con el valor del operador igual a la unidad, es cierto que los elementos con números yonorteremetroyyonorteremetro+1No se convierten. Al realizar alguna iteración, llamaremos a un elemento de un nuevo vector (x) atómico si el valor de este elemento se tomó del vector original u se obtuvo mediante la concatenación de valores atómicos. Llamaremos a un elemento de un nuevo vector (y) transformado si es el resultado de realizar una de seis operaciones aritméticas binarias con números del 2 al 7, en una de las iteraciones que preceden a esta.

Para cada vector, el número de operaciones y la elección de pares de valores(yonortere,yonortere+1)limitado, el número de iteraciones que preceden a la recepción del resultado (el número a) también es limitado. En consecuencia, hay un número finito de enteros para los cuales el problema de Tanezhi tiene una solución ascendente. También es posible mostrar con ejemplos que diferentes secuencias de iteraciones no siempre conducen a resultados diferentes, y que no todas esas secuencias tienen un resultado completo o al menos válido. Además, las estadísticas, en particular, los resultados del trabajo de Bill Ams, muestran que el número de valores racionales de salida diferentes no puede exceder el doble del número de valores enteros diferentes. Por lo tanto, la primera generalización importante del problema de Tanezhi es el siguiente conjunto de preguntas:

  • ¿Cuántas conclusiones diferentes tienen un resultado entero?
  • ¿Cuántos enteros de módulo salen?
  • ¿Cuántos valores complejos diferentes se muestran?
  • ¿Es cierto que el número de diferentes valores racionales deducidos y el módulo que no excede algún entero k no excede el doble del número de diferentes números enteros deducidos que el módulo no excede k? ¿Para qué k? ¿Es cierto en general?

También es cierto que al derivar un valor entero, de modo que en algunas iteraciones intermedias, el vector contiene valores irracionales y complejos, la probabilidad de obtener diferentes valores totales disminuye, ya que una serie de operaciones (sumando lo irracional a lo racional, elevando lo racional al grado irracional) no devuelve un resultado racional, pero porque el número de opciones se reduce. Por lo tanto, surge otra generalización:
Para probar o refutar eso para cualquier número entero a es cierto: si el problema de Tanezhi en orden ascendente para a no tiene una solución en la que todas las iteraciones de la salida se realicen en vectores que no tienen elementos irracionales, entonces no tiene solución.

Progreso de la decisión


Primero, implementamos la función de contar el número de todas las conclusiones que pueden considerarse soluciones para algunos a, no necesariamente el todo (es decir, todas las conclusiones para las cuales la operación con el código 1 se realiza solo en operandos atómicos). El lenguaje de implementación es C #.

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

El resultado del programa:

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

Tenemos alrededor de 112 mil millones de opciones. Por construcción, muchas opciones de salida no solo producirán el mismo valor, sino que también tendrán la misma representación infija (obtenga el número deseado, utilizando los mismos operadores, en los mismos operandos, pero en un orden diferente). Por ejemplo, si la primera iteración convirtió elementos1 y 2 a 1+2=3y los segundos elementos 3 y 3 a 3+3=6 6 y si la primera iteración convirtió los elementos 2 y 3 a 2+3=5 5y los segundos elementos 1 y 5 5 a 1+5 5=6 6, en ambos casos obtenemos una expresión infija:

1+2+3=6 6


Describimos algunas clases de inferencias con una representación infija resultante que se repite:

  • dejemos que el operador de suma se realice en operandos, uno de los cuales es el resultado de la suma, luego podemos restringirnos a iteraciones en las que el operando correcto no es el resultado de la suma y el resultado de cálculos anteriores es un elemento cuyo índice es como máximo yonortere+1 . 1+(2+3) (1+2)+3, 1+2+3+4 4∗(5 5+6 6) 5 5+6 6 1+2+3,
  • : ,
  • , 7, : (unasi)C=(una-si)-con, , , una-si unasi
  • ( ) , .. . : una∗(si/ /C)=una∗si/ /C una/ /(si/ /C)=una/ /si∗C

La implementación de operadores que tengan en cuenta estas clases no garantiza la ausencia de repeticiones entre las expresiones infijadas, pero BOO le permite descartar algunas de estas repeticiones.

Los valores de los elementos de los vectores para algunas conclusiones no son computables, debido al tamaño limitado de la palabra máquina. Usando el tipo de datos BigInteger, será posible calcular algunos de estos valores. Declare la estructura de datos para el elemento vector. Habrá dos enteros largos en él, que representan el numerador y el denominador de algún número racional. Para cada operador, escribimos una serie de condiciones adicionales que garantizan un resultado racional sin desbordamiento. Al agregar códigos de operación y restricciones en las clases de valores infix repetidos a la misma estructura, obtenemos la función Num_1, que BOO cuenta el número de conclusiones que tienen diferentes representaciones infix. Obviamente, no se perderá ninguna solución, en el sentido de que si para un cierto número a hubiera un mínimo de 1 salida en Num_0,entonces habrá al menos una salida en Num_1 para ello.

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

El resultado de la nueva prueba:

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

Recibió alrededor de 4762 millones de expresiones.

En la estructura de datos para el elemento vector, también creamos un campo de cadena en el que se acumulará la representación infija de la salida. Al final de la cadena de iteración (cuando se llama recursivamente a la función Num_2 con una matriz de longitud 1), verificaremos la contractilidad de la fracción que representa un elemento de este vector y compararemos el resultado de dividir el numerador por el denominador con un cierto número. Al ingresar la variable del contador, obtenemos un procedimiento, cuyo resultado será el número de salidas del número val con las condiciones dadas. Para números10958 y 5479=10958/ /2 (Dónde 5479 - simple) obtenemos:

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

La salida contendrá el número de conclusiones, cuyo resultado se pudo calcular con precisión, así como expresiones infijadas para todas las conclusiones de su número calculado, que terminó con la obtención del valor de val.

Resultado
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

Entonces, para limitar los grados enteros a no más de 27 en valor absoluto, los resultados de ~ 957 millones de conclusiones resultaron ser computables, y entre ellos 356 son las conclusiones del número 5479 y no una sola conclusión (y en consecuencia no una sola conclusión con las operaciones de suma, resta, concatenación, multiplicación y división, así como algunas conclusiones con las mismas operaciones y algunas potencias enteras) no es una conclusión del número 10958. ¿Cuál es su característica?

Fantasmas y sombras


Para una tarea similar al problema de Tanezhi en orden ascendente, pero con vectores iniciales de longitud 8, como (1,2,...,8) y (2,3,...,9 9)el número de opciones es menor, y con los valores enteros irracionales, complejos y largos de los elementos de los vectores (1) - (7), los algoritmos optimizados de Wolfram Mathematics hacen frente. Por lo tanto, se sabe con certeza que ni una sola conclusión en(1,2,...,9 9), que tiene el operador de concatenación, suma o resta en la octava iteración, no puede conducir al valor 10958. ¿Qué posibilidades ofrece esto para otras soluciones?

El número 10958 es semisimple. Y si la última iteración de la salida no contiene suma, resta y concatenación, entonces se garantizará que uno de los operandos en la octava iteración incluya 5479 hasta cierto punto, con la excepción de dos casos:

  1. cuando los operandos son múltiplos de algún conjugado complejo
  2. cuando uno de los operandos contiene un logaritmo cuya base o exponente es un múltiplo de 5479

Y si el primer caso está dentro de la fuerza de las mismas matemáticas de Wolfram, entonces el segundo debe considerarse por separado. Hasta la fecha, no se ha encontrado ninguna conclusión en la que el elemento del vector de salida en cualquier iteración sea un logaritmo que satisfaga el Caso 2. Además, existe un teorema general:
Teorema 1: dejar α=losolunasidónde una y si- mutuamente simple Entoncesα no deducible sobre un vector arbitrario (C1,C2,...,Cnorte) longitud finita n, donde C1,C2,...,Cnorte - enteros algebraicos

Recuerdo que un número entero algebraico es cualquier número para el cual existe un polinomio con coeficientes enteros y un coeficiente líder de la unidad de modo que una de las raíces de este polinomio sea un número dado.
Si hay una prueba formal de este teorema, la búsqueda de soluciones al problema de Tanezhi puede reducirse significativamente. Uno de los métodos de búsqueda que le permite verificar solo las conclusiones que tienen más probabilidades de obtener el valor deseado se llama "método de fantasmas y sombras" y fue propuesto por mí.

Definición: Dejar en alguna iteración de alguna conclusión sobre(1,2,...,9 9) uno de los elementos del vector de iteración resultante es igual a un primer p, entonces la representación infija de este elemento se llamará el fantasma de p en esta salida sobre (1,2,...,9 9).

Definición: Dejar en alguna iteración de alguna conclusión sobre(1,2,...,9 9) uno de los elementos del vector resultante es un número racional, cuyo numerador o denominador está dividido por un número primo p, y este elemento no es un fantasma, entonces la representación infija de este elemento se llamará la sombra del número p en esta salida sobre (1,2,...,9 9).

La tabla de fantasmas y sombras para el número 5479 será cientos de miles de veces más pequeña que el número total de conclusiones sobre Num_1. Además, al combinar manualmente características con los otros elementos del vector de iteración de salida, en el que se encontraron fantasmas o sombras, se pueden obtener conclusiones con grados irracionales y complejos, así como con grandes números enteros y racionales, que se cortaron en Num_2. Describimos la función Num_3 para buscar fantasmas y sombras y agregamos la salida del archivo a nuestro proyecto.

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

La conclusión fue voluminosa, mostraré varias de sus secciones:

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

Considera el fantasma: 5479=(-1)+((2∗(345-6 6)+7 7)∗8). De todos los elementos del vector inicial, nueve permanecen sin usar, pero por encima del vector(5479,9 9)irreductiblemente 10958. Del mismo modo, debe analizar 65 fantasmas y sombras 10802. En Internet, hay varias grandes comunidades matemáticas involucradas en la "finalización" de problemas exhaustivos, como fue el caso con el problema de mosaico de planos. Sin embargo, si bien el teorema sobre la derivabilidad de los logaritmos con una base y argumento mutuamente simples no se ha probado, no se trata de un mayor refinamiento. En la siguiente sección, estudiaremos con más detalle la cuestión de la enumeración automática de todas las conclusiones para vectores arbitrarios de longitud finita con elementos algebraicos enteros.

Vistas discretas


El concepto de una representación discreta completa.


Todos conocemos el problema de la finitud de los algoritmos, sobre la clase de NP: tareas que en teoría requieren recursos de hardware ilimitados para calcular una solución en un tiempo que aumenta linealmente. Pero en las facultades de informática, en los institutos de investigación y en los lugares de trabajo, a menudo se ignora un problema igualmente importante en la unión de la programación y la informática: el problema de la representabilidad de los datos.

Entonces, de las matemáticas sabemos que los números racionales de la formauna/ /sidónde una y si - naturales mutuamente simples, representables como una fracción decimal finita, si está en la representación canónica del número si todos los primos que no sean 2 y 5 tienen grado cero, de lo contrario una/ /si puede representarse como una fracción infinita, que será periódica, ya que una/ /siNo es irracional. Luego, verificación de igualdad de máquina:

√3=√√12∗√3/ /4 4(1)

Hay varias formas de hacer esto. Cada método dependerá de su propia estructura de datos y tendrá una cierta eficiencia. Aquí hay algunas opciones:

  1. Utilizamos dos variables de coma flotante. Este método tiene una ventaja obvia: se dedicará el tiempo mínimo a escribir un programa. Pero al calcular secuencialmente la aproximación real de la raíz de 12, la aproximación real de la raíz de 3/4, la pérdida de precisión al multiplicar dos pérdidas reales e incluso mayores con un cálculo aproximado, podemos obtener un número real cercano a la raíz de los tres, y evaluar el error absoluto del cálculo para determinar la probabilidad cumplimiento de igualdad (1)
  2. . . . , , , « ». . :
    1. 3=√α; 3=α α=√32=3
    2. : √√12∗√3/ /4 4 α=√12∗√3/ /4 4=√β; β , : β=α2=9 9
    3. 12∗3 4. 0, . 12∗3/ /4 4=9 9; , 2 3 : (1) .. 9 9=9 9

    , ,
  3. « ». : una,si,C, : (una/ /si)1/ /C : , . :

    (3,1,2)=√√(12,1,1)∗√(3,4 4,1)=√(12,1,2)∗(3,4 4,2)==√(36,4 4,2)=√(9 9,1,2)=√(3,1,1)=(3,1,2);

    (una,si,C), , (1)

La "Estructura X" es un buen ejemplo de una estructura de datos que es una representación discreta completa. La teoría de las representaciones discretas de números irracionales y trascendentales es un nuevo campo de las matemáticas discretas, a las que se debe prestar más atención.

Definición: dejar resolver el problemaY para cada vector de valores de entrada de un conjunto finito METRO tales vectores, y para alguna estructura de datos StrtuCtnortekdescribiendo cada elemento del vector como un conjunto de norte números naturales, módulo no superior a 2lminorte-1dónde lminorte - el tamaño de la palabra máquina del artista en bits, cierto:

  • algoritmo UNAlsolrealizando la tarea UNA en el lenguaje de L se detendrá con la emisión del resultado correcto (correspondiente al formato de salida, interpretado de manera única y siendo la solución al problema UNA por encima de un vector dado de valores de entrada)
  • para cada etapa del algoritmo Alg, los valores de todas las variables de tipo inicializadas StrtuCtnortek (resultados de cálculos intermedios) se pueden interpretar sin ambigüedades, su valor numérico se puede restaurar y usar con precisión al rastrear manualmente el algoritmo mientras se mantiene la salida correcta

entonces una descripción formal StrtuCtnortek en algún lenguaje de programación declarativo imperativo, L se llamará representación discreta completa (LAP) con respecto a L para resolver el problema A sobre el conjunto de vectores de valores de entrada de M y denotar: L(UNA,METRO,StrtuCtnortek)=trtumi

RAP mínimo


Existen métodos formales para construir estructuras de datos que satisfacen los criterios RAP. Uno de estos: el método de cierre finito. El cierre de un conjunto con respecto a un conjunto de operaciones se considera el conjunto de todos los números que se pueden obtener realizando un número finito de operaciones permitidas en elementos del conjunto original. Por ejemplo: para un conjunto finito {0, 1} y un conjunto de operaciones: la suma binaria y el cierre unario menos serán un conjuntoZtodos los enteros De hecho: para obtener un número naturalnortesuficiente para doblar norte unidades a recibir -norte de nortepuede usar el unario menos, y no se deducirán los valores no enteros.

En el método de cierre finito, estamos interesados ​​en muchosMETROyo todos los elementos del circuito METRO muchos UNA con respecto a un conjunto de operaciones opagstal que para generar cualquier valor de METROyo no más que yo operaciones de opags sobre operandos de UNA. Deje que al resolver un problema determinado, un conjunto de todo tipo de conjuntos de valores de entrada deUNAen el que el algoritmo para resolver el problema se detiene con el resultado correcto de tal manera que cuando este algoritmo se ejecuta en cualquiera de estos conjuntos, todos los valores intermedios (los valores de las variables inicializadas en alguna etapa del algoritmo) estarán en METROyo. Entonces se prueba que existe un MAPA que consiste en no más dePAGS enteros para una palabra máquina de longitud 2, donde PAGS Es el poder del bulean METROyo

Para el problema de Tanezhi, el método de cierre finito no es aplicable debido al gran tamaño del bulean para el cierre METRO9 9con respecto a siete operaciones en el conjunto inicial de dígitos del 1 al 9. Por lo tanto, surge la cuestión de minimizar el número n: el número de variables enteras que describen el elemento del vector de valores intermedios en un algoritmo que implementa la solución del problema de Tanezhi en orden ascendente.

Definición: LetLX - muchas representaciones discretas completas {L(UNA,METRO,StrtuCtnortek)} y por algún elemento Lyo(UNA,METRO,StrtuCtnorteyo,k) (i es el número de secuencia del elemento del conjunto) es cierto:

  • ∀j≠yo:Lj(UNA,METRO,StrtuCtnortej,k)=trtumi⇒norteyo,k⩽nortej,k

entonces llamaremos al elemento {Lyo(UNA,METRO,StrtuCtnorteyo,k)} la representación discreta completa mínima (mínimo LDP) con respecto a L para resolver el problema A sobre el conjunto de vectores de valores de entrada de M y denotar: L(metroyonorte)(UNA,METRO,StrtuCtnortek)=trtumi

De hecho, el problema de Tanezhi, en la forma en que se presenta en la sección "redacción exacta y primeras generalizaciones", es un problema completo de representación discreta, y la estructura de datos NumEx utilizada en los algoritmos de búsqueda de salida Num_2 y Num_3 es un ejemplo de una estructura de datos estar completo incluso en un solo vector (1,2,...,9 9). La construcción del DAP mínimo para el problema de Tanezhi en orden ascendente es una etapa importante para demostrar la ausencia de una conclusión para el número 10958.

Nueva trascendentología


Por supuesto, números trascendentales y exactamente trascendentales.


A menudo, las consecuencias de los teoremas, cuya prueba era necesaria para resolver un determinado problema, resultan ser más valiosas que la tarea misma. Este fue el caso con la justificación formal de la imposibilidad de construir una cuadratura de un círculo con una brújula y una regla, con el pequeño problema de Goldbach y una serie de otros problemas matemáticos. Esto está sucediendo hoy. El enunciado del problema de representar números naturales usando siete operaciones en un determinado vector inicial le dio al mundo no solo hermosas soluciones particulares y la misteriosa constante 10958, sino también un enfoque especial para la clasificación de cantidades cuyos valores no siempre pueden escribirse en forma explícita. Por lo tanto, se demuestra que los números radicales tienen una intersección distinta de cero con el conjunto de números algebraicos, pero no están completamente incluidos en este último.

Al escribir programas que inevitablemente se deben a las condiciones del problema, debe realizar cálculos que contengan números π y mi según la calidad de los operandos, generalmente están limitados por su representación aproximada o intentan programar el cálculo analítico del límite para series que convergen en π y mirespectivamente. Si el formato para generar el resultado final del programa y los detalles de los cálculos permiten el uso de números como símbolos, entonces la presencia del componente trascendental cae inevitablemente en el RAP como mínima como una variable del atributo. Compare las dos estructuras de datos y los números que representan y evalúe la optimización de resolver un determinado problema abstracto sobre cada estructura:

  1. (una,si)=una/ /si
  2. (una,si,sipags,C,Cpags,re)=(una+si∗πsipags+C∗miCpags)/ /re

Obviamente, la PDL mínima en el caso de números trascendentales puede no ser la PDL óptima en términos de complejidad de tiempo para alguna implementación del algoritmo en un lenguaje declarativo imperativo.

Definición: letuna1,una2 - algunos números algebraicos reales (no necesariamente diferentes) y para algunos números reales trascendentales τ Hay una representación infija: τ=una1opagsuna2dónde opags- operador binario del conjunto: suma, resta, multiplicación, división, exponenciación. Entonces el numeroτ será llamado 1-trascendental y denotado qtrunanortes(τ)=1

Definición: letuna Es un número algebraico real, τk Es un número k-trascendental, luego llamaremos a algún número τ (k + 1) -transcendental y denotar qtrunanortes(τ)=k+1si no es 1-trascendental, 2-trascendental ... k-trascendental y hay una representación infija τ=τkopagsunadónde opags- operador binario del conjunto: suma, resta, multiplicación, división, exponenciación.

Definición: Númeroτ será llamado trascendental finito y denotado qtrunanortes(τ)≠yonorteF si por algún número natural norte justa: qtrunanortes(τ)=norte

Definición: Númeroτ será llamado exacto-trascendental y denotado qtrunanortes(τ)=yonorteFsi es válido, trascendental y no trascendental finito.

Con la introducción del concepto de número trascendental finito, se hace posible operar con los valores exactos de algunos números trascendentales sin usar sus símbolos. En general, se afirma que para algunos subconjuntos del conjunto de números trascendentales finitos hay conjuntos de problemas no vacíosUNA sobre los vectores de valor de entrada que consisten en números algebraicos, de modo que para cualquier problema de UNA ninguno de los valores intermedios o de salida del elemento RAP durante la operación del algoritmo que implementa la solución de este problema desde UNA no es exactamente trascendental entre todas las implementaciones de este algoritmo en algún lenguaje declarativo imperativo Lla implementación con un mínimo RAP tendrá la menor complejidad de tiempo. El poder del conjunto A de tales problemas depende directamente del ordenqtrunanortes.

Expresiones tau


Entonces, en el conjunto de números trascendentales, se puede distinguir en 3 subconjuntos disjuntos (por construcción), cuya unión coincidirá con el conjunto de todos los números trascendentales, a saber:

  1. números trascendentales finitos
  2. números trascendentales de precisión
  3. números trascendentales complejos

Y si para finito-trascendental podemos construir el RAP de acuerdo con el método de cierre finito y tratar de minimizarlo, entonces exactamente para trascendental (al cual, además de valores obvios π y mi, el Gelfond también incluirá los logaritmos decimales de números racionales que no son potencias enteras exactas de 10 y algunos otros valores que son importantes desde un punto de vista práctico). En la sección actual, se propone considerar un conjunto de números, incluidos los números finitos trascendentales y exactamente trascendentales y que poseen algunas propiedades importantes para la teoría de representaciones discretas completas. Se trata de un número infinito.τ-expresiones (léase: expresiones tau), así como algunos de sus subconjuntos contables.

Definición:τ-form (leer: tau-form) del primer orden se llamará una función τ1(α)definido para cualquier argumento α∈{0 0,1} y dado por la tabla de valores: τ1(0 0)=mi;τ1(1)=π. Designacion:qtrunanortesol(τ1(α))=1

Definición: τforma de orden norte llamaremos a la función τnorte(α1,α2,...,αnorte)definido para cada vector (α1,α2,...,αnorte)dónde αyo∈{0 0,1},yo=¯1,nortedado por una de las igualdades:

  • τnorte(α1,α2,...,αnorte)=τL(α1,α2,...,αk)+τRUNA(αk+1,αk+2,...,αnorte)
  • τnorte(α1,α2,...,αnorte)=τ1(α1)τR(α2,α3,...,αnorte)

Dónde τ1(α) - τformulario de primer orden τL(α1,α2,...,αk) - τforma de orden kllamado mayor izquierdo τformas τnorte(α1,α2,...,αnorte), τR(α2,α3,...,αnorte) - τforma de orden norte-1llamado derecho mayor τformas τnorte(α1,α2,...,αnorte), τRUNA(αk+1,αk+2,...,αnorte) - τforma de orden norte-kllamado el complemento correcto τformas τnorte(α1,α2,...,αnorte). Designaciones:qtrunanortesol(τnorte(α1,α2,...,αnorte))=norte,Lmetrounaj(τnorte(α1,α2,...,αnorte))=τL(α1,α2,...,αk),Rmetrounaj(τnorte(α1,α2,...,αnorte))=τR(α2,α3,...,αnorte), Runarere(τnorte(α1,α2,...,αnorte))=τRUNA(αk+1,αk+2,...,αnorte).

porτformas τnorte(α1,α2,...,αnorte) dado τSe considerará un formulario de primer orden y un complemento mayor derecho o mayor izquierdo y mayor, respectivamente, complemento mayor izquierdo y derecho o mayor derecho indefinido.

Definición:τ-expresión de orden norte llamaremos al valor τformas τnorte(α1,α2,...,αnorte) ordenar n en algún vector (una1,una2,...,unanorte)llamado el vector de conducción τ-formas donde unayo∈{0 0,1},yo=¯1,norte.

También definimos los conceptos de complemento derecho e izquierdo mayor y derecho paraτ-expresiones, como el significado del complemento derecho e izquierdo mayor y el complemento derecho, respectivamente τformas τnorte(α1,α2,...,αnorte)definiendo esta expresión en el subsector correspondiente del vector definitorio.

Ejemplosτ-expresiones:

π+mimi; mimiπ+mi+mimi+mi; ππmi+mi;

Definición: términos principalesτ-expresiones τnorte de orden norte tipo:

τnorte=τ1,1τk1,1+τ1,2τk2,2+
...+τ1,metroτkmetro,metro+τ1,metro+1+τ1,metro+2+
...+τ1,metro+pagsdónde:
τ1,yo - algunos τexpresiones de primer orden yo=¯1,metro+pags,
τkj,j - algunos τ-expresiones de orden kj, j=¯1,metro
y norte=metro+pags+k1+k2+...+kmetro
llamaremos elementos de la forma:
τ1,q y τ1,rτkr,rdónde q=¯metro+1,metro+pags, r=¯1,metro

Una forma de grabar τ-formar:

τ(α1,α2,α3,α4 4,α5 5)=τ1(α1)τ1(α2)+τ1(α3)+τ1(α4 4)+τ1(α5 5)dónde qtrunanortesol(τ1(α))=1

Tantos τ-expresiones de orden finito es un caso especial de cierre del conjunto π,micon respecto a las operaciones de suma y multiplicación. Subconjuntoτ-expresiones del mismo orden siempre se pueden pedir.

Usando número de serieτ-expresiones como PDP le permite comparar τ-expresiones y realizar algunas operaciones en ellas sin ningún error, además:
Teorema 2. Al restringir el orden de todas las expresiones tau a un número determinado norte para muchas tareas UNAPara lo cual el RAP representa todas esas expresiones, hay una implementación L(UNAlsol) en un lenguaje declarativo imperativo L para algún algoritmo UNAlsoltal que para la línea de entrada - descripciones en cualquier lenguaje declarativo imperativo L′ Estructuras de datos RAP de alguna tarea una desde A, el algoritmo se detendrá con la salida de la cadena - descripciones en el lenguaje L′ RAP mínimo para la estructura de datos del algoritmo L(UNAlsol′) - implementación del algoritmo UNAlsol′ resolución de problemas una en el idioma L.

Teniendo en cuenta el problema de Tanezhi en orden ascendente, es importante comprender que ninguno de los elementos del vector de iteración de entrada (1), (2) y (3) contiene (tras probar enumerando todas estas iteraciones) elementos trascendentales. De la definición de trascendencia finita y sobre la base de lo anterior, se deduce la no deducibilidadkvalores trascendentales para el problema de Tanezhi en orden ascendente en k>6 6. Por lo tanto, al probar la ausencia de una conclusión para el número10958 solo verifique la deducibilidad de todos metronúmeros trascendentales τmetro y números algebraicos α sobre todos los subvectores vectoriales (1,2,...,9 9)tal que: 10958=τmetroopagsα,metro<6 6dónde opags Es alguna operación del conjunto de admisible para iteración (8) dada por el triple (opags,1,2). Esta condición es suficiente: es decir irreductibilidad de todos esos pares que representan el número10958, demuestra la irreductibilidad del número en sí 10958, pero lo contrario no es cierto: desde la salida hasta metro-transcendental aún no sigue la solución al problema original.

Teorema general "Sobre cierres de conjuntos finitos de números trascendentales"


Definición: llamaremosτ-expresión τnortede orden norte normal si una de las condiciones es verdadera:

  • τnorte numéricamente igual a uno de los valores: π,mi,π+mi y norte∈1,2
  • norte>2 y derecho mayor τnorte definido y normal
  • norte>2izquierda mayor τnorte definido y normal, complemento derecho τnorte representaciones definidas y normales y algebraicas de la izquierda mayor τnorte y el complemento adecuado τnorte no contienen términos principales similares.

Tenga en cuenta que la normalidad τ-expresiones, en el sentido simple, significa la ausencia de tales términos en la notación algebraica de este τ-expresiones.

Ejemplos:

πmi+miπ bien
mimi+π+π+miπ+mi - No es normal, ya que: mimi+π+π+miπ+mi=mimi+π+mimi+π+π=2∗mimi+π+π

Definición: τ-expresión τ0 0=τnorte(una1,una2,...,unanorte) llamaremos a la raíz de algunos τformas τnorte(α1,α2,...,αnorte) de orden nortesi esta expresión es normal y la desigualdad es válida:
qtrunanortes(τnorte(una1,una2,...,unanorte))⩽norte,
dondeunayo∈{0 0,1},yo=¯1,norte

Teorema 3. Cada subconjunto contable de un conjunto τ-formas de orden finito incluyen un número finito τ-formas que tienen al menos una raíz.

Permítame recordarle que un contador es un conjunto que se puede poner en correspondencia uno a uno con el conjunto Q enteros
Teorema 4. Dejar METRO - cierto conjunto de números reales que satisfacen las siguientes condiciones:

  • METRO por supuesto o contablemente
  • METRO contiene al menos un elemento exactamente trascendental
  • circuito ¯METRO muchos METRO con respecto a un conjunto de operaciones binarias: la suma y exponenciación es continua

entonces cada subconjunto contable del conjunto ¯METRO incluye un número finito de elementos trascendentales finitos.

Un corolario importante del Teorema 3 es la existencia de un mínimo de MAP para algoritmos que realizan cálculos solo en números algebraicos y finitos trascendentales. El teorema 4 da una idea general de la distribución de números trascendentales finitos entre todos los números trascendentales reales y es valioso como herramienta teórica para clasificar grupos, anillos y cierres con respecto a exponentes que contienen elementos trascendentales.

Resumen


La teoría de los números finito-trascendentales como consecuencia del problema de Tanezhi y parte del nuevo aparato matemático necesario para resolver el problema del número 10958 es una herramienta importante, cuya aplicación práctica en la programación y el significado teórico para la topología como ciencia difícilmente pueden subestimarse. Existen clasificaciones completas de números racionales, algebraicos, los números complejos y las funciones por encima de ellos se estudian en detalle, y solo los números trascendentales siguen siendo un misterio para los matemáticos modernos. Busca raíces arbitrariasτLas formas como ejercicio a lo largo del tiempo ayudarán a desarrollar un nuevo enfoque para resolver los problemas de clasificación de números reales.

El problema de Tanezhi revela el problema de una representación discreta completa y muestra la inconsistencia de los métodos populares para describir la estructura de datos al resolver problemas matemáticos en una PC. Entonces, para una enumeración completa de todas las conclusiones del problema de Tanezhi sobre un vector(1,2,...,7 7)el error de cálculo absoluto cuando se usa el tipo Complejo con dos componentes, los números de coma flotante, no permitirá resolver la cuestión de la derivabilidad no solo de un número entero específico, sino también la cuestión de la derivabilidad de al menos un número entero / racional de un intervalo corto.

En un examen superficial del problema del número 10958, los artículos de matemáticos populares solo señalaron el problema de los "números astronómicos": este es el nombre de los números (a menudo enteros) cuya notación decimal es imposible. Ejemplos vívidos - número6 67 789 9que se acuesta sobre el vector (1,2,...,9 9) o calificación norte≈10101034la aparición de un error negativo en la ley de Chebyshev sobre la distribución de números primos. De hecho, los valores intermedios en el cálculo de la salida pueden ser no solo números astronómicos, sino también números complejos y trascendentales, la implementación de operaciones aritméticas con las cuales y el cálculo de errores de cálculo son difíciles.

Por un lado, la matemática científica popular educa a las nuevas generaciones de agricultores, lo que afecta negativamente la imagen de la ciencia profesional. Por otro lado, atraer la atención de una audiencia multimillonaria hacia problemas matemáticos no resueltos da lugar a muchos puntos de vista alternativos sobre formulaciones y posibles soluciones, y algunas de estas ideas forman la base del trabajo de matemáticos profesionales. Así sucedió con la tarea de Erdös, y hoy el trabajo amateur de Inder Tanega sobre las maravillosas representaciones de enteros puede cambiar las matemáticas modernas y darle a la esfera de TI un nuevo enfoque para la descripción de las estructuras de datos.

Referencias


More articles:


All Articles