↪️ 🙍🏼 👩🏿‍🤝‍👨🏽 A tarefa de Tanezhi: uma nova etapa no desenvolvimento da matemática? 🤲🏼 🔹 👍🏻

Introdução

A matemática do século XXI é fundamentalmente diferente da antiga. E não se trata apenas de novos avanços em geometria e aritmética - ciências, cujos princípios básicos foram formados há milênios. Com o advento da tecnologia da computação, a prioridade mudou e a teoria dos números do campo dos "exercícios para o desenvolvimento da mente" se transformou em uma ciência, cujas realizações dependem da economia mundial.

Sobre o problema dos gêmeos simples, sobre a hipótese do ABC, o problema de Goldbach-Vinogradov e alguns outros problemas matemáticos importantes, novas publicações científicas populares são publicadas diariamente. Por um lado, essas tarefas resistiram ao teste do tempo e, por outro, o RP regular é suportado por recompensas de seis dígitos para cada um. Porém, há quatro anos, nas obras de um matemático brasileiro, um problema foi levantado, indireta e imperceptivelmente para si mesmo, que poderia se tornar o objetivo e o sentido da vida dos matemáticos deste século. Estamos falando da classificação de números transcendentais no que diz respeito ao fechamento de conjuntos finitos de números algébricos.

Desafio Inder Tanezhi

Informação geral

Inder Tanega é um matemático popularizador brasileiro que dedicou a maior parte de sua vida a quadrados mágicos, números triangulares e outras tarefas divertidas. Ele nunca assumiu os problemas não resolvidos do século, não fez uma contribuição profissional para o estudo das propriedades da série natural, mas foi em seus estudos amadores que surgiram questões que a matemática moderna não pode responder.

Tudo começou com uma série de publicações no Reddit, onde Tanezh falou sobre a possibilidade de representar qualquer número natural menor que um determinado limite usando um número limitado de operandos. A idéia em si não é nova e, nas edições soviéticas para as olimpíadas, essas questões surgiam periodicamente:

Imagine o número 1958 usando sete duques, colocando os operadores de adição, subtração, multiplicação e elevação à potência

A resposta será:

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

A seleção de uma apresentação incomum para o ano atual se tornou uma tradição para os departamentos de matemática de muitas universidades e se tornou mais forte na literatura. O mesmo acontecia com os problemas da simplicidade de grandes números: há alguns séculos, os números de Mersenne e Fermat estavam envolvidos por interesse esportivo, e agora os primeiros fornecem criptografia com chaves privadas confiáveis. E há quatro anos, apareceu uma publicação na qual eles consideravam possíveis maneiras de resolver o problema de representar um número natural usando um dígito, bem como representações ordenadas com todos os dígitos, exceto zero. Por exemplo:

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

Entre as operações permitidas estavam inicialmente:

concatenação: 2 || 3 = 23
adição: 2 + 3 = 5
subtração: 2-3 = -1
multiplicação: 2 * 3 = 6
unário menos: - (2 + 3) = - 5

Tanezha considerou a divisão inútil, já que números de até mil poderiam ser representados como o exemplo acima, sem operações adicionais. Porém, no futuro, ele acrescentou ao mínimo necessário a exponenciação (incluindo graus com indicadores racionais, irracionais e complexos fracionários, se tais surgiram nos cálculos intermediários e levaram a todo o resultado no final dos cálculos) e a divisão.

Um ano depois, um trabalho volumoso saiu com uma tabela de representações de números de 1 a 11 111, usando números em ordem crescente e decrescente. O conjunto de operações indicado acima acabou sendo suficiente para representar todos os números em dígitos em ordem decrescente, bem como representar 11 110 números da lista em ordem crescente.

Em busca de aprovação, Inder envia seu trabalho com comentários pessoais para matemáticos profissionais e blogueiros populares. Entre outros destinatários está Matt Parker - o rosto do projeto australiano "Stand-up matemático" e um dos participantes do projeto do YouTube "Numberphile". O vídeo sobre o número especial 10958 (o único espaço na tabela de decomposições de Tanezh) tornou-se popular o suficiente para que tentativas de resolução e artigos científicos populares sobre Tanezh aparecessem às vezes em todo o mundo.

Astrônomo louco e um autor desconhecido do Yandex.Zen trouxeram a tarefa para a Rússia. Este último adicionou notícias sobre um prêmio de US $ 5.000 por encontrar uma solução para o número 10958. No entanto, nem Tanezh, nem Parker, nem funcionários do MIT sabem nada sobre o prêmio público. Em três anos, apenas dois trabalhos amadores foram lançados, fazendo pelo menos algumas tentativas de encontrar soluções. A primeira foi publicada por um ex-participante do projeto TedX e diz respeito à questão de avaliar o número total de expressões computáveis construídas de acordo com as regras de Tanezh e o tempo de execução do algoritmo exaustivo. O segundo visa a "fraca expansão" da tarefa, a saber:

Apresente todos os números de 1 a 11 111 111 usando números em ordem crescente (um dígito pode ser usado uma vez e cada dígito deve ser usado), organizando os operadores: a) binário: adição, subtração, multiplicação, divisão, aumentando a potência; b) unário: unário menos, fatorial, raiz quadrada

Esse enfraquecimento, segundo o autor do estudo, foi suficiente para representar 11 111 105 números. Relatório de vídeo original:

Não foram feitas tentativas para fornecer uma prova analítica precisa da impossibilidade de representação do número 10958 na forma que precisamos; em qualquer caso, as informações sobre eles não estão disponíveis em nenhum dos idiomas estrangeiros disponíveis para mim. A impossibilidade de uma solução exaustiva e os recursos do número 10958 serão descritos em mais detalhes abaixo.

Redação exata e primeiras generalizações

A formulação livre do autor do problema deu origem a muitas decisões erradas com base em uma interpretação incorreta da condição. Os erros mais comuns:

o uso de concatenação “externa”: é permitida a compilação de novos operadores a partir dos dígitos do vetor inicial, mas é proibida a concatenação de forma geral, como anexar um número à direita de outro. Exemplos: $2||3=23$ - lata, $(1+2)||3=33$ - é impossível
arredondamento: resolver o problema de Tanezhi em números inteiros significa não apenas usar um vetor inicial inteiro, mas também obter um resultado inteiro na saída. Exemplos: $8=(1-2+3)*4$ - lata, $7 \approx (1+2/3)*4=20/3$ - é impossível
o uso de operandos adicionais: ao realizar a operação de aumentar a potência, alguns autores consideram o conjunto inicial de números como fundamento válido para o grau e recorrem a indicadores arbitrários. Exemplos: $31=(1+2^3)*4-5$ - lata, $10958 = (1+2^3)*3+4^3+5*6*7+8^4+9^4$ - é impossível

Descrevemos o processo de verificação e tomada de decisão do problema de Tanezhi para um determinado número. Deixe algum vetor de números complexos (no caso geral)

$(c_1, c_2, ..., c_k)$ propôs três

$(op, ind,ind+1)$ Onde

$ind$ e

$ind+1$ - números naturais consecutivos,

$ind_1<=k$ ;

$op$ - código do operador - um número natural de 1 a 7 e, em seguida, iteração

$(op, ind,ind+1)$ sobre o vetor

$(c_1, c_2, ..., c_k)$ chamaremos o processo cujo resultado é um vetor de comprimento

$k-1$ , a saber:

vetor $(c_1, c_2, ... , _{ind-1}, c_{ind}||c_{ind+1}, c_{ind+2}, ... , c_k)$ para $op=1$
vetor $(c_1, c_2, ... , _{ind-1}, c_{ind}+c_{ind+1}, c_{ind+2}, ... , c_k)$ para $op=2$
vetor $(c_1, c_2, ... , _{ind-1}, |c_{ind}-c_{ind+1}|, c_{ind+2}, ... , c_k)$ para $op=3$
vetor $(c_1, c_2, ... , _{ind-1}, c_{ind}*c_{ind+1}, c_{ind+2}, ... , c_k)$ para $op=4$
vetor $(c_1, c_2, ... , _{ind-1}, c_{ind}/c_{ind+1}, c_{ind+2}, ... , c_k)$ para $op=5$
vetor $(c_1, c_2, ... , _{ind-1}, c_{ind}^{c_{ind+1}}, c_{ind+2}, ... , c_k)$ para $op=6$
vetor $(c_1, c_2, ... , _{ind-1}, c_{ind}^{-(c_{ind+1})}, c_{ind+2}, ... , c_k)$ para $op=7$

Seja dado o vetor inicial

$(1, 2, ... , 9)$ de nove elementos iguais aos seus números de série. Então eles dizem que por algum número inteiro

$a$ existe uma solução para o problema de Tanezhi em ordem crescente, se houver uma sequência (que chamaremos de derivação para o número a):

$(op_1, ind_1,{ind_1}+1)$ É uma iteração sobre o vetor inicial, cujo resultado é o vetor (1)

$(op_2, ind_2,{ind_2}+1)$ É uma iteração sobre o vetor (1), cujo resultado é o vetor (2)
...

$(op_8, ind_8,{ind_8}+1)$ É uma iteração sobre o vetor (7), cujo resultado é o vetor (8), de

modo que o vetor (8) é igual ao vetor

$(a)$ qualquer vetor

$(-a)$ e para cada iteração com o valor do operador igual à unidade, é verdade que elementos com números

$ind_m {ind_m}+1$ não são convertidos. Ao executar alguma iteração, chamaremos um elemento de algum novo vetor (x) atômico se o valor desse elemento for retirado do vetor original ou obtido pela concatenação de valores atômicos. Chamaremos um elemento de algum novo vetor (y) transformado se for o resultado da realização de uma das seis operações aritméticas binárias com números de 2 a 7, em uma das iterações anteriores a este.

Para cada vetor, o número de operações e a possibilidade de escolher pares de valores

$(ind, ind+1)$ limitado, o número de iterações anteriores ao recebimento do resultado - o número a - também é limitado. Conseqüentemente, há um número finito de números inteiros para os quais o problema de Tanezhi em uma ordem crescente tem uma solução. Também é possível mostrar por exemplos que sequências diferentes de iterações nem sempre levam a resultados diferentes e também que nem todas essas sequências têm um resultado total ou pelo menos real. Além disso, as estatísticas, em particular os resultados do trabalho de Bill Ams, mostram que o número de diferentes valores racionais de saída não pode exceder o dobro do número de diferentes valores inteiros. Portanto, a primeira generalização importante do problema de Tanezhi é o seguinte conjunto de perguntas:

Quantas conclusões diferentes com um resultado inteiro existem?
Quantos números inteiros de módulo são produzidos?
Quantos valores complexos diferentes são exibidos?
É verdade que o número de diferentes valores racionais deduzidos e o módulo que não exceda algum número inteiro k não exceda o dobro do número de diferentes números inteiros deduzidos que não excedam k? Para qual k? Isso é verdade em geral?

Também é verdade que, ao derivar um valor inteiro, de modo que, em algumas iterações intermediárias, o vetor contém valores irracionais e complexos, a probabilidade de obter diferentes valores totais diminui, pois várias operações (adicionando o irracional ao racional, elevando o racional ao grau irracional) não retornam um resultado racional, mas porque o número de opções é reduzido. Portanto, surge outra generalização:

Para provar ou refutar que, para qualquer número inteiro a, é verdade: se o problema de Tanezhi em ordem crescente para a não tiver uma solução na qual todas as iterações da saída sejam executadas em vetores que não possuem elementos irracionais, não haverá solução.

Progresso da decisão

Primeiro, implementamos a função de contar o número de todas as conclusões que podem ser consideradas soluções para alguns a - não necessariamente o todo (isto é, todas as conclusões para as quais a operação com o código 1 é realizada apenas em operandos atômicos). A linguagem de implementação é C #.

Nós temos:

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

O resultado do programa:

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

Temos cerca de 112 bilhões de opções. Por construção, muitas opções de saída não apenas produzirão o mesmo valor, mas também terão a mesma representação de infixo (obtenha o número desejado, usando os mesmos operadores, nos mesmos operandos, mas em uma ordem diferente). Por exemplo, se a primeira iteração converter elementos

$1$ e

$2$ às

$1+2=3$ e os segundos elementos

$3$ e

$3$ às

$3+3=6$ e se a primeira iteração converter os elementos

$2$ e

$3$ às

$2+3=5$ e os segundos elementos

$1$ e

$5$ às

$1+5=6$ , em ambos os casos, obtemos uma expressão infix:

$1+2+3=6$

Descrevemos algumas classes de inferências com uma representação de infixo resultante repetida:

que o operador de adição seja executado em operandos, um dos quais é o resultado da adição, podemos nos restringir a iterações nas quais o operando certo não é o resultado da adição e o resultado de cálculos anteriores é um elemento cujo índice é no máximo $ind+1$ . $1+(2+3)$ $(1+2)+3$ , $1+2+3+4*(5+6)$ $5+6$ $1+2+3$ ,
: ,
, 7, : ${({a^b})}^c={{(a^{-b}})}^{-}$ , , , $a^{-b}$ $a^b$
( ) , .. . : $a*(b/c) = a*b/c$ $a/(b/c)=a/b*c$

A implementação dos operadores que levam essas classes em consideração não garante a ausência de repetições entre expressões infix, mas o BOO permite descartar algumas dessas repetições.

Os valores dos elementos dos vetores para algumas conclusões não são computáveis, devido ao tamanho limitado da palavra da máquina. Usando o tipo de dados BigInteger, será possível calcular alguns desses valores. Declare a estrutura de dados para o elemento do vetor. Haverá dois números inteiros longos, representando o numerador e o denominador de algum número racional. Para cada operador, escrevemos várias condições adicionais que garantem um resultado racional sem transbordamento. Adicionando códigos de operação e restrições às classes de repetição de valores de infix na mesma estrutura, obtemos a função Num_1, que BOO conta o número de conclusões com diferentes representações de infix. Obviamente, nenhuma solução será perdida, no sentido de que, para um determinado número, houvesse no mínimo 1 saída em Num_0,haverá pelo menos uma saída em Num_1 para ele.

Nós temos

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

O resultado do novo teste:

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

Recebeu cerca de 4762 milhões de expressões.

Na estrutura de dados para o elemento vetorial, também criamos um campo de sequência no qual a representação do infixo da saída se acumulará. No final da cadeia de iteração (ao chamar recursivamente a função Num_2 com uma matriz de comprimento 1), verificaremos a contratilidade da fração que representa o elemento desse vetor e compararemos o resultado da divisão do numerador pelo denominador com um determinado número. Entrando na variável do contador, obtemos um procedimento, cujo resultado será o número de saídas do número val com as condições especificadas. Para números

$10958$ e

$5479=10958/2$ (Onde

$5479$ - simples) temos:

Fonte

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

A saída conterá o número de conclusões, cujo resultado pôde ser calculado com precisão, bem como expressões infix para todas as conclusões do número calculado, que terminaram com a obtenção do 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

Portanto, para limitar graus inteiros a não mais que 27 em valor absoluto, os resultados de ~ 957 milhões de conclusões se tornaram computáveis, e entre eles 356 estão as conclusões do número 5479 e não uma única conclusão (e, portanto, não uma única conclusão com as operações de adição, subtração, concatenação, multiplicação e divisão, bem como algumas conclusões com as mesmas operações e algumas potências inteiras) não é uma conclusão do número 10958. Qual é a sua característica?

Fantasmas e sombras

Para uma tarefa semelhante ao problema de Tanezhi em ordem crescente, mas com vetores iniciais de comprimento 8, como

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

$(2, 3, ... , 9)$ o número de opções é menor e, com os valores inteiros irracionais, complexos e longos dos elementos dos vetores (1) - (7), os algoritmos otimizados da Wolfram Matemáticas lidam com isso. Portanto, é sabido com segurança que nem uma única conclusão

$(1, 2, ... , 9)$ , que possui o operador de concatenação, adição ou subtração na 8ª iteração, não pode levar ao valor 10958. Que possibilidades isso oferece para soluções adicionais?

O número 10958 é semi-simples. E se a última iteração da saída não contiver adição, subtração e concatenação, será garantido que um dos operandos na 8ª iteração inclua 5479 até certo ponto, exceto em dois casos:

quando os operandos são múltiplos de algum conjugado complexo
quando um dos operandos contém um logaritmo cuja base ou expoente é um múltiplo de 5479

E se o primeiro caso estiver dentro da força da mesma matemática de Wolfram, o segundo deverá ser considerado separadamente. Até o momento, nenhuma conclusão foi encontrada em que o elemento do vetor de saída em qualquer iteração fosse um logaritmo que satisfaz o Caso 2. Além disso, existe um teorema geral:

Teorema 1: deixe $\alpha = log_ab$ Onde $a$ e $b$ - mutuamente simples. Então $\alpha$ não dedutível sobre um vetor arbitrário $(c_1, c_2, ... , c_n)$ comprimento finito m $c_1, c_2, ... , c_n$ - inteiros algébricos

Lembro-me de que um número inteiro algébrico é qualquer número para o qual exista um polinômio com coeficientes inteiros e uma unidade que conduz o coeficiente de forma que uma das raízes desse polinômio seja um número determinado.
Se houver uma prova formal desse teorema, a busca de soluções para o problema de Tanezh pode ser significativamente reduzida. Um dos métodos de pesquisa que permite verificar apenas as conclusões com maior probabilidade de obter o valor desejado é chamado "método de fantasmas e sombras" e foi proposto por mim.

Definição: Deixe em alguma iteração de alguma conclusão sobre

$(1, 2, ... , 9)$ Se um dos elementos do vetor de iteração resultante for igual a um primo p, a representação do infixo desse elemento será chamada fantasma de p nesta saída sobre

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

Definição: Deixe em alguma iteração de alguma conclusão sobre

$(1, 2, ... , 9)$ um dos elementos do vetor resultante é um número racional, cujo numerador ou denominador é dividido por um número primo p, e esse elemento não é um fantasma, a representação do infix desse elemento será chamada de sombra do número p nesta saída sobre

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

A tabela de fantasmas e sombras para o número 5479 será centenas de milhares de vezes menor que o número total de conclusões no Num_1. Além disso, combinando recursos manualmente com o restante dos elementos do vetor de iteração de saída, nos quais fantasmas ou sombras foram encontrados, é possível obter conclusões com graus irracionais e complexos, bem como com graus inteiros e racionais grandes, que foram cortados em Num_2. Descrevemos a função Num_3 para pesquisar fantasmas e sombras e adicionamos saída de arquivo ao nosso projeto.

Fonte

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

A conclusão foi volumosa, vou mostrar várias de suas seções:

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

Considere o fantasma:

$5479 = (-1)+((2*(345-6)+7)*8)$ . De todos os elementos do vetor inicial, nove permanecem sem uso, mas acima do vetor

$(5479, 9)$ irredutivelmente 10958. Da mesma forma, você precisa analisar 65 fantasmas e 10802 sombras. Na Internet, existem várias grandes comunidades matemáticas envolvidas na "conclusão" de problemas exaustivos, como foi o caso do problema de ladrilhos de avião. No entanto, embora o teorema da derivabilidade de logaritmos com base e argumento mutuamente simples não tenha sido provado, não há dúvida de refinamentos adicionais. Na próxima seção, estudaremos mais detalhadamente a questão da enumeração por máquina de todas as conclusões para vetores arbitrários de comprimento finito com elementos algébricos inteiros.

Visualizações discretas

O conceito de uma representação discreta completa

Todos nós sabemos sobre o problema de finitude dos algoritmos, sobre a classe de NP - tarefas que, em teoria, exigem recursos de hardware ilimitados para calcular uma solução em tempo linearmente crescente. Mas nas faculdades de ciência da computação, em institutos de pesquisa e nos locais de trabalho, um problema igualmente importante na junção de programação e ciência da computação é frequentemente ignorado - o problema da representabilidade dos dados.

Então, da matemática sabemos que números racionais da forma

$a/b$ Onde

$a$ e

$b$ - naturais mutuamente simples, representáveis como uma fração decimal finita, se na representação canônica do número

$b$ todos os números primos diferentes de 2 e 5 têm grau zero, caso contrário

$a/b$ pode ser representado como uma fração infinita, que será periódica, pois

$a/b$ não é irracional. Em seguida, verifique a igualdade da máquina:

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

Existem várias maneiras de fazer isso. Cada método dependerá de sua própria estrutura de dados e terá uma certa eficiência. Aqui estão algumas opções:

Usamos duas variáveis de ponto flutuante. Este método tem uma vantagem óbvia: o tempo mínimo será gasto na criação de um programa. Mas, calculando sequencialmente a aproximação real da raiz de 12, a aproximação real da raiz de 3/4, a perda de precisão ao multiplicar duas perdas reais e ainda maiores com cálculo aproximado, podemos obter um número real próximo à raiz dos três e avaliar o erro absoluto do cálculo para determinar a probabilidade cumprimento da igualdade (1)
. . . , , , « ». . :
1. $3 = {\sqrt {\alpha}}$ ; $3 = {\alpha}$ ${\alpha}={\sqrt 3}^2=3$
2. : ${\sqrt {{\sqrt 12}*{\sqrt {3/4}}}}$ ${\alpha}={{\sqrt 12}*{\sqrt {3/4}}}={\sqrt {\beta}}$ ; $\beta$ , : ${\beta}={{\alpha}^2}=9$
3. $12*3$ 4. 0, . $12*3/4=9$ ; , 2 3 : (1) .. $9=9$
, ,
« ». : $a, b, c$ , : ${(a/b)}^{1/c}$ : , . :

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

$(a,b,c)$ , , (1)

"Estrutura X" é um bom exemplo de uma estrutura de dados que é uma representação discreta completa. A teoria das representações discretas de números irracionais e transcendentais é um novo campo da matemática discreta, que deve receber mais atenção.

Definição: deixar de resolver o problema

para cada vetor de valores de entrada de um conjunto finito

$M$ tais vetores e para alguma estrutura de dados

$Struct_{n_k}$ descrevendo cada elemento do vetor como um conjunto de

$n$ números naturais, módulo não superior a

$2^{len-1}$ Onde

$len$ - o tamanho da palavra-máquina do artista em bits, verdadeiro:

algoritmo $Alg$ realizando a tarefa $A$ no idioma L irá parar com a emissão do resultado correto (correspondente ao formato de saída, interpretado exclusivamente e sendo a solução para o problema $A$ acima de um determinado vetor de valores de entrada)
para cada estágio do algoritmo Alg, os valores de todas as variáveis inicializadas do tipo $Struct_{n_k}$ (resultados de cálculos intermediários) podem ser interpretados sem ambiguidade, seu valor numérico pode ser restaurado com precisão e usado ao rastrear manualmente o algoritmo, mantendo a saída correta

então uma descrição formal

$Struct_{n_k}$ em alguma linguagem de programação declarativa imperativa, L será chamada de representação discreta completa (LAP) em relação a L para resolver o problema A sobre o conjunto de vetores de valores de entrada de M e denotar:

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

RAP mínimo

Existem métodos formais para construir estruturas de dados que atendem aos critérios do RAP. Um deles: o método de fechamento finito. O fechamento de um conjunto em relação a um conjunto de operações é considerado o conjunto de todos os números que podem ser obtidos executando um número finito de operações permitidas nos elementos do conjunto original. Por exemplo: para um conjunto finito {0, 1} e um conjunto de operações: adição binária e fechamento menos unário serão um conjunto

$Z$ todos os números inteiros. De fato: para obter um número natural

$n$ o suficiente para dobrar

$n$ unidades a receber

$-n$ do

$n$ você pode usar o menos unário e os valores não inteiros não serão deduzidos.

No método de fechamento finito, estamos interessados em muitos

$M_i$ todos os elementos do circuito

$M$ muitos

$A$ sobre um conjunto de operações

$op$ de modo a gerar qualquer valor de

$M_i$ não mais que

$i$ operações de

$op$ sobre operandos de

$A$ . Deixe ao resolver um determinado problema, um conjunto de todos os tipos de conjuntos de valores de entrada de

$A$ em que o algoritmo para resolver o problema para com o resultado correto, sendo que, quando esse algoritmo é executado em qualquer um desses conjuntos, todos os valores intermediários (os valores das variáveis inicializadas em algum estágio do algoritmo) ficam em

$M_i$ . Está provado que existe um MAP que consiste em não mais que

$P$ inteiros para uma palavra de máquina com comprimento 2, em que

$P$ É o poder do bulean do conjunto

$M_i$

Para o problema de Tanezhi, o método de fechamento finito não é aplicável devido ao grande tamanho do bulean para fechamento

$M_9$ em relação a sete operações no conjunto inicial de dígitos de 1 a 9. Portanto, surge a questão de minimizar o número n - o número de variáveis inteiras que descrevem o elemento do vetor de valores intermediários em um algoritmo que implementa a solução do problema de Tanezhi em ordem crescente.

Definição: Let

$L_x$ - muitas representações discretas completas

$\{ L(A,M, Struct_{n_k})\}$ e para algum elemento

$L_{i}(A,M, Struct_{n_{i,k}})$ (i é o número de sequência do elemento do conjunto) é verdadeiro:

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

então vamos chamar o elemento

$\{ L_{i}(A,M, Struct_{n_{i,k}})\}$ a representação discreta completa mínima (mínimo LDP) em relação a L para resolver o problema A sobre o conjunto de vetores de valores de entrada M e denotar:

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

De fato, o problema de Tanezhi, na forma em que é apresentado na seção “redação exata e primeiras generalizações”, é um problema completo de representação discreta, e a estrutura de dados NumEx usada nos algoritmos de busca de saída Num_2 e Num_3 é um exemplo de estrutura de dados não sendo completo mesmo em um único vetor

$(1, 2, ... , 9)$ . A construção do DAP mínimo para o problema de Tanezhi em ordem crescente é uma etapa importante para provar a ausência de uma conclusão para o número 10958.

Nova Transcendentologia

Claro, números transcendentais e exatamente transcendentais

Freqüentemente, as conseqüências dos teoremas, cuja prova era necessária na solução de um determinado problema, acabam sendo mais valiosas do que a própria tarefa. Foi o caso da justificativa formal da impossibilidade de construir uma quadratura de círculo com uma bússola e uma régua, com o pequeno problema de Goldbach e vários outros problemas matemáticos. Isso está acontecendo hoje. A formulação do problema de representar números naturais usando sete operações em um determinado vetor inicial deu ao mundo não apenas belas soluções particulares e a constante misteriosa 10958, mas também uma abordagem especial para a classificação de quantidades cujos valores nem sempre podem ser escritos de forma explícita. Portanto, está provado que números radicais têm uma interseção diferente de zero com o conjunto de números algébricos, mas eles não estão completamente incluídos no último.

Ao escrever programas que são inevitavelmente devidos às condições do problema, é necessário executar cálculos contendo números

$\pi$ e

$e$ à qualidade dos operandos, eles geralmente são limitados por sua representação aproximada ou tentam programar o cálculo analítico do limite para séries que convergem para

$\pi$ e

$e$ respectivamente. Se o formato para gerar o resultado final do programa e as especificidades dos cálculos permitirem o uso de números como símbolos, a presença do componente transcendental inevitavelmente cai no RAP tão mínimo quanto uma variável do atributo. Compare as duas estruturas de dados e os números que eles representam e avalie a otimalidade de resolver um determinado problema abstrato sobre cada uma dessas estruturas:

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

Obviamente, o PDL mínimo no caso de números transcendentais pode não ser o PDL ideal em termos de complexidade de tempo para alguma implementação do algoritmo em uma linguagem declarativa imperativa.

Definição: let

$a_1, a_2$ - alguns números algébricos reais (não necessariamente diferentes) e para alguns números reais transcendentais

$\tau$ Há uma representação de infixo:

$\tau = a_1 op a_2$ Onde

$op$ - operador binário do conjunto: adição, subtração, multiplicação, divisão, exponenciação. Então o número

$\tau$ será chamado 1-transcendental e denotado

$qtrans({\tau})=1$

Definição: let

$a$ É algum número algébrico real,

${\tau}_{k}$ É um número k-transcendental, então chamaremos algum número

$\tau$ (k + 1) - transcendental e denota

$qtrans({\tau})=k+1$ se não é 1-transcendental, 2-transcendental ... k-transcendental e existe uma representação de infixo

${\tau}={\tau}_k op a$ Onde

$op$ - operador binário do conjunto: adição, subtração, multiplicação, divisão, exponenciação.

Definição: Número

$\tau$ será chamado transcendental finito e denotado

$qtrans({\tau})\neq inf$ se por algum número natural

$n$ justo:

$qtrans({\tau})=n$

Definição: Número

$\tau$ será chamado exato-transcendental e denotado

$qtrans({\tau})= inf$ se é válido, transcendental e não transcendental finito.

Com a introdução do conceito de número transcendental finito, torna-se possível operar com os valores exatos de alguns números transcendentais sem usar seus símbolos. Em geral, afirma-se que, para alguns subconjuntos do conjunto de números transcendentais finitos, existem conjuntos de problemas não vazios

$A$ vetores de valor de entrada que consistem em números algébricos, de modo que, para qualquer problema de

$A$ nenhum dos valores intermediários ou de saída do elemento RAP durante a operação do algoritmo que implementa a solução desse problema de

$A$ não é precisamente transcendental entre todas as implementações desse algoritmo em alguma linguagem declarativa imperativa

$L$ a implementação com o mínimo de RAP terá a menor complexidade de tempo. A potência do conjunto A de tais problemas depende diretamente da ordem

$qtrans$ .

Expressões de tau

Assim, no conjunto de números transcendentais, é possível distinguir em 3 subconjuntos disjuntos (por construção), cuja união coincidirá com o conjunto de todos os números transcendentais, a saber:

números transcendentais finitos
números transcendentais de precisão
números transcendentais complexos

E se para finito-transcendental podemos construir o RAP de acordo com o método de fechamento finito e tentar minimizá-lo, então para exatamente transcendental (para o qual, além de valores óbvios

${\pi}$ e

$e$ , o Gelfond também incluirá os logaritmos decimais de números racionais que não são potências inteiras exatas de 10 e alguns outros valores importantes do ponto de vista prático). Na seção atual, propõe-se considerar um conjunto de números, incluindo números finito-transcendental e exatamente-transcendental e possuindo algumas propriedades importantes para a teoria de representações discretas completas. É sobre um número infinito

${\tau}$ -expressions (leia-se: expressões tau), bem como alguns de seus subconjuntos contáveis.

Definição:

$\tau$ -form (read: tau-form) de primeira ordem será chamado de função

${\tau}_1 ({\alpha})$ definido para qualquer argumento

$\alpha \in \{0, 1\}$ e dado pela tabela de valores:

${\tau}_1 (0) = e; {\tau}_1 (1) = \pi$ . Designação:

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

Definição:

$\tau$ forma de pedido

$n$ vamos chamar a função

${\tau}_n ({\alpha}_1, {\alpha}_2, ... , {\alpha}_n)$ definido para cada vetor

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

${\alpha}_i \in \{0, 1\}, i=\overline{\rm 1, n}$ dada por uma das igualdades:

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

Onde

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

$\tau$ formulário de primeira ordem

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

$\tau$ forma de pedido

$k$ chamado esquerda principal

$\tau$ formulários

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

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

$\tau$ forma de pedido

$n-1$ chamado major certo

$\tau$ formulários

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

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

$\tau$ forma de pedido

$n-k$ chamado o complemento certo

$\tau$ formulários

${\tau}_n ({\alpha}_1, {\alpha}_2, ... , {\alpha}_n)$ . Designações:

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

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

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

Para

$\tau$ formulários

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

$\tau$ Uma forma de primeira ordem e o complemento maior direito ou esquerdo maior e direito serão considerados, respectivamente, complemento maior e direito esquerdo ou maior indefinido.

Definição:

$\tau$ -expressão de ordem

$n$ vamos chamar o valor

$\tau$ formulários

${\tau}_n({\alpha}_1, {\alpha}_2, ... , {\alpha}_n)$ ordem n em algum vetor

$({a}_1, {a}_2, ... , {a}_n)$ chamado o vetor de condução

$\tau$ -forma onde

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

Também definimos os conceitos de complemento principal e direito direito e esquerdo para

$\tau$ -expressões, como o significado do complemento maior e do lado direito e esquerdo, respectivamente

$\tau$ formulários

${\tau}_n({\alpha}_1, {\alpha}_2, ... , {\alpha}_n)$ definindo esta expressão no subsetor correspondente do vetor de definição.

Exemplos

$\tau$ -expressões:

$\pi + e^e$ ;

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

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

Definição: Termos principais

$\tau$ -expressões

${\tau}_n$ de ordem

$n$ tipo:

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

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

$... + {\tau}_{1,m+p}$ Onde:

${\tau}_{1, i}$ - alguns

$\tau$ expressões de primeira ordem

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

${\tau}_{k_j,j}$ - alguns

$\tau$ -expressões de ordem

$k_j$ ,

$j=\overline{\rm 1,m}$
e

$n = m+p + k_1 + k_2 + ... + k_m$
chamaremos elementos do formulário:

${\tau}_{1,q}$ e

${{\tau}_{1,r}}^{{\tau}_{k_r,r}}$ Onde

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

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

Uma maneira de gravar

$\tau$ -Formato:

${\tau}({\alpha}_1, {\alpha}_2, {\alpha}_3, {\alpha}_4, {\alpha}_5) = {\tau}_1({\alpha}_1)^{{\tau}_1({\alpha}_2)}+{\tau}_1({\alpha}_3) +{\tau}_1({\alpha}_4) + {\tau}_1({\alpha}_5)$ Onde

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

Muitos

$\tau$ -expressões de ordem finita é um caso especial de fechamento do conjunto

${\pi, e}$ sobre operações de adição e multiplicação. Subconjunto

$\tau$ sempre podem ser solicitadas expressões da mesma ordem.

Usando número de série

$\tau$ -expressões como PDP permite comparar

$\tau$ -expressions e execute algumas operações nelas sem nenhum erro, além disso:

Teorema 2. Ao restringir a ordem de todas as expressões tau a um determinado número $n$ para muitas tarefas $A$ Para o qual o RAP representa todas essas expressões, existe uma implementação $L(Alg)$ em uma linguagem declarativa imperativa $L$ para algum algoritmo $Alg$ tal que para a linha de entrada - descrições em qualquer linguagem declarativa imperativa $L'$ Estruturas de dados RAP de alguma tarefa $a$ de A, o algoritmo irá parar com a saída da string - descrições no idioma $L'$ RAP mínimo para a estrutura de dados do algoritmo $L(Alg')$ - implementação do algoritmo $Alg'$ Solução de problemas $a$ no idioma $L$ .

Considerando o problema de Tanezhi em ordem crescente, é importante entender que nenhum dos elementos do vetor de iteração de entrada (1), (2) e (3) contém (comprovado pela enumeração de todas essas iterações) elementos transcendentais. A partir da definição de transcendência finita e com base no exposto, segue-se a não dedutibilidade

$k$ transcendental para o problema de Tanezhi em ordem crescente em

$k>6$ . Portanto, ao provar a ausência de uma conclusão para o número

$10958$ basta verificar a dedutibilidade de todos

$m$ números transcendentais

${\tau}_m$ e números algébricos

$\alpha$ sobre todos os subvectores vectoriais

$(1, 2, ... , 9)$ de tal modo que:

$10958 = {\tau}_m op \alpha, m<6$ Onde

$op$ Há alguma operação do conjunto de admissíveis para a iteração (8) dada pelo triplo

$(op, 1, 2)$ . Essa condição é suficiente: ou seja, irredutibilidade de todos esses pares representando o número

$10958$ , comprova a irredutibilidade do próprio número

$10958$ , mas o inverso não é verdadeiro - da saída para a

$m$ -transcendental ainda não segue a solução para o problema original.

Teorema geral "Sobre fechamentos de conjuntos finitos de números transcendentais"

Definição: chamaremos

$\tau$ -expressão

${\tau}_n$ de ordem

$n$ normal se uma das condições for verdadeira:

${\tau}_n$ numericamente igual a um dos valores: $\pi , e, \pi +e$ e $n \in {1, 2}$
$n>2$ e grande direita ${\tau}_n$ definido e normal
$n>2$ esquerda maior ${\tau}_n$ definido e normal, complemento direito ${\tau}_n$ representações definidas e normais e algébricas da esquerda maior ${\tau}_n$ e o complemento certo ${\tau}_n$ não contêm termos principais semelhantes.

Observe que normalidade

$\tau$ -expressões, no sentido simples, significa a ausência de tais termos na notação algébrica deste

$\tau$ -expressões.

Exemplos:

${\pi}^e+e^{\pi}$ - bem

$e^{e+{\pi}}+{\pi}+e^{{\pi}+e}$ - não é normal, pois:

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

Definição:

$\tau$ -expressão

${\tau}_0={\tau}_n(a_1, a_2, ... , a_n)$ chamaremos a raiz de alguns

$\tau$ formulários

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

$n$ se essa expressão for normal e a desigualdade for válida:

$qtrans({{\tau}_n(a_1, a_2, ... , a_n)}) \leqslant n$ ,
onde

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

Teorema 3. Todo subconjunto contável de um conjunto $\tau$ -formas de ordem finita incluem um número finito $\tau$ -forms com pelo menos uma raiz.

Deixe-me lembrá-lo de que um contável é um conjunto que pode ser colocado em uma correspondência individual com o conjunto

$Q$ inteiros.

Teorema 4. Vamos $M$ - um determinado conjunto de números reais que satisfaz as seguintes condições:

$M$ claro ou contável
$M$ contém pelo menos um elemento exatamente transcendental
o circuito $\overline{\rm M}$ muitos $M$ em relação a um conjunto de operações binárias: adição e exponenciação são contínuas

então todos os subconjuntos contáveis do conjunto $\overline{\rm M}$ inclui um número finito de elementos transcendentais finitos.

Um corolário importante do Teorema 3 é a existência de um mínimo de MAP para algoritmos que realizam cálculos apenas em números algébricos e finitos-transcendentais. O teorema 4 dá uma idéia geral da distribuição de números transcendentais finitos entre todos os números transcendentais reais e é valioso como uma ferramenta teórica para classificar grupos, anéis e fechamentos em relação aos expoentes que contêm elementos transcendentais.

Sumário

A teoria dos números transcendentais finitos como consequência do problema de Tanezhi e parte do novo aparato matemático necessário para resolver o problema do número 10958 é uma ferramenta importante cuja aplicação prática em programação e o significado teórico da topologia como ciência dificilmente podem ser subestimados. Existem classificações abrangentes de números racionais e algébricos, números e funções complexas acima deles são estudados em detalhes, e apenas números transcendentais permanecem um mistério para os matemáticos modernos. Procure raízes arbitrárias

$\tau$ As formas como exercício ao longo do tempo ajudarão a desenvolver uma nova abordagem para resolver os problemas de classificação de números reais.

O próprio problema de Tanezhi revela o problema de uma representação discreta completa e mostra a inconsistência de métodos populares para descrever a estrutura de dados ao resolver problemas matemáticos em um PC. Portanto, para uma enumeração completa de todas as conclusões do problema de Tanezhi sobre um vetor

$(1, 2, ... , 7)$ o erro absoluto dos cálculos ao usar o tipo Complex com dois componentes - números de ponto flutuante - não permitirá resolver a questão da derivabilidade de não apenas um número inteiro específico, mas também a questão da derivabilidade de pelo menos um número inteiro / racional a partir de um intervalo curto.

Em um exame superficial do problema do número 10958, os artigos de matemáticos popularizadores notaram apenas o problema dos “números astronômicos” - esse é o nome dos números (na maioria das vezes inteiros) cuja notação decimal é impossível. Exemplos vívidos - número

$6^{7^{8^9}}$ que se deitam sobre o vetor

$(1, 2, ... , 9)$ ou classificação

$N\approx 10^{10^{10^{34}}}$ o aparecimento de um erro negativo na lei de Chebyshev na distribuição de números primos. De fato, os valores intermediários no cálculo da saída podem ser não apenas números astronômicos, mas também números complexos e transcendentais, a implementação de operações aritméticas com as quais o cálculo dos erros de cálculo é difícil.

Por um lado, a matemática das ciências populares educa as novas gerações de agricultores, o que afeta negativamente a imagem da ciência profissional. Por outro lado, atrair a atenção de uma platéia multimilionária para problemas matemáticos não resolvidos gera muitas visões alternativas sobre formulações e possíveis soluções, e algumas dessas idéias formam a base do trabalho de matemáticos profissionais. O mesmo aconteceu com a tarefa de Erdös, e hoje o trabalho amador de Inder Tanega sobre as maravilhosas representações de números inteiros pode mudar a matemática moderna e dar à esfera de TI uma nova abordagem para a descrição das estruturas de dados.

A tarefa de Tanezhi: uma nova etapa no desenvolvimento da matemática?

Introdução

Desafio Inder Tanezhi

Informação geral

Redação exata e primeiras generalizações

Progresso da decisão

Fantasmas e sombras

Visualizações discretas

O conceito de uma representação discreta completa

RAP mínimo

Nova Transcendentologia

Claro, números transcendentais e exatamente transcendentais

Expressões de tau

Teorema geral "Sobre fechamentos de conjuntos finitos de números transcendentais"

Sumário

Referências

More articles: