Get best of the week

Tanezhis Aufgabe: eine neue Stufe in der Entwicklung der Mathematik?

Einführung


Die Mathematik des 21. Jahrhunderts unterscheidet sich grundlegend von der Antike. Dabei geht es nicht nur um neue Fortschritte in der Geometrie und den Arithmetikwissenschaften, deren Grundprinzipien vor Jahrtausenden formuliert wurden. Mit dem Aufkommen der Computertechnologie hat sich die Priorität geändert, und die Zahlentheorie aus dem Bereich der „Übungen zur Entwicklung des Geistes“ hat sich zu einer Wissenschaft entwickelt, von deren Errungenschaften die Weltwirtschaft abhängt.

Zum Problem der einfachen Zwillinge, zur ABC-Hypothese, zum Goldbach-Vinogradov-Problem und zu einigen anderen wichtigen mathematischen Problemen werden täglich neue populärwissenschaftliche Veröffentlichungen veröffentlicht. Einerseits haben sich diese Aufgaben bewährt, andererseits wird die regelmäßige PR durch jeweils sechsstellige Belohnungen unterstützt. Vor vier Jahren wurde in den Werken eines brasilianischen Mathematikers indirekt und unmerklich ein Problem für sich aufgeworfen, das für Mathematiker dieses Jahrhunderts zum Ziel und Sinn des Lebens werden könnte. Wir sprechen über die Klassifizierung transzendentaler Zahlen im Hinblick auf die Schließung endlicher Mengen algebraischer Zahlen.

Fordern Sie Inder Tanezhi heraus


Allgemeine Information


Inder Tanega ist ein brasilianischer Popularisierungsmathematiker, der den größten Teil seines Lebens magischen Quadraten, Dreieckszahlen und anderen unterhaltsamen Aufgaben gewidmet hat. Er hat die ungelösten Probleme des Jahrhunderts nie aufgegriffen, keinen professionellen Beitrag zur Erforschung der Eigenschaften der natürlichen Reihen geleistet, aber in seinen Amateurstudien wurden Fragen aufgeworfen, die die moderne Mathematik nicht beantworten kann.

Alles begann mit einer Reihe von Veröffentlichungen in Reddit, in denen Tanezh über die Möglichkeit sprach, eine natürliche Zahl kleiner als eine bestimmte Grenze mit einer begrenzten Anzahl von Operanden darzustellen. Die Idee selbst ist nicht neu, und in den sowjetischen Ausgaben für Olympiaden tauchten regelmäßig solche Fragen auf:
Stellen Sie sich die Zahl 1958 mit sieben Zweien vor und setzen Sie die Operatoren Addition, Subtraktion, Multiplikation und Erhöhung auf eine Potenz

Die Antwort lautet:

1958 = 22 2 ≤ 2 ≤ 2 + 22


Die Auswahl einer ungewöhnlichen Präsentation für das laufende Jahr hat für die mathematischen Fakultäten vieler Universitäten Tradition und ist in der Literatur stärker geworden. Dasselbe galt für die Probleme der Einfachheit großer Zahlen: Vor einigen Jahrhunderten wurden Mersenne- und Fermat-Zahlen aus sportlichem Interesse eingesetzt, und jetzt versorgen erstere die Kryptographie mit zuverlässigen privaten Schlüsseln. Und vor 4 Jahren erschien eine Veröffentlichung, in der sie über mögliche Wege zur Lösung des Problems der Darstellung einer natürlichen Zahl mit einer Ziffer sowie über geordnete Darstellungen mit allen Ziffern außer Null nachdachten. Zum Beispiel:

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


:

  • : 2||3=23
  • : 2+3=5
  • : 2-3=-1
  • : 2*3=6
  • : -(2+3)=-5

Tanezha hielt die Teilung für nutzlos, da Zahlen bis zu tausend wie im obigen Beispiel ohne zusätzliche Operationen dargestellt werden könnten. In Zukunft fügte er jedoch dem erforderlichen Minimum eine Erhöhung des Abschlusses (einschließlich der Abschlüsse mit gebrochenen rationalen, irrationalen und komplexen Indikatoren, falls dies in den Zwischenberechnungen auftrat und am Ende der Berechnungen zum Gesamtergebnis führte) und der Division hinzu.

Ein Jahr später erschien eine umfangreiche Arbeit mit einer Tabelle mit Darstellungen von Zahlen von 1 bis 11 111, wobei Zahlen in aufsteigender und absteigender Reihenfolge verwendet wurden. Der oben angegebene Satz von Operationen erwies sich als ausreichend, um alle Zahlen in absteigender Reihenfolge sowie 11 110 Zahlen aus der Liste in aufsteigender Reihenfolge darzustellen.

Auf der Suche nach Zustimmung verschickt Inder seine Arbeit mit persönlichen Kommentaren an professionelle Mathematiker und Popularisierer von Bloggern. Unter den Empfängern ist Matt Parker - das Gesicht des australischen Projekts „Mathematical Stand-up“ und einer der Teilnehmer des YouTube-Projekts „Numberphile“. Das Video über die Sondernummer 10958 (der einzige Platz in der Zerlegungstabelle von Tanezh) wurde populär genug, um Versuche zu lösen, und populärwissenschaftliche Artikel über Tanezh tauchten manchmal auf der ganzen Welt auf.


Der verrückte Astronom und ein unbekannter Autor aus Yandex.Zen brachten die Aufgabe nach Russland. Letzterer fügte Nachrichten über einen Preis von 5.000 US-Dollar für die Suche nach einer Lösung für die Nummer 10958 hinzu. Weder Tanezh noch Parker oder MIT-Mitarbeiter wissen jedoch etwas über die öffentliche Auszeichnung. In drei Jahren kamen nur zwei Amateurarbeiten heraus, die zumindest einige Versuche unternahmen, Lösungen zu finden. Der erste wurde von einem ehemaligen Teilnehmer des TedX-Projekts veröffentlicht und betrifft die Frage der Bewertung der Gesamtzahl der berechenbaren Ausdrücke, die gemäß den Tanezh-Regeln erstellt wurden, und der Laufzeit des umfassenden Algorithmus. Die zweite zielt auf eine "schwache Erweiterung" der Aufgabe ab, nämlich:

Stellen Sie alle Zahlen von 1 bis 11 111 111 mit Zahlen in aufsteigender Reihenfolge dar (eine Ziffer kann einmal verwendet werden und jede Ziffer muss verwendet werden), und ordnen Sie die Operatoren wie folgt an: a) binär: Addition, Subtraktion, Multiplikation, Division, Exponentiation; b) unär: unär minus, faktoriell, Quadratwurzel

Diese Schwächung reichte laut Autor der Studie aus, um 11 111 105 Zahlen darzustellen. Original Video Bericht:


Es wurden keine Versuche unternommen, einen genauen analytischen Nachweis für die Nichtrepräsentierbarkeit der Nummer 10958 in der von uns benötigten Form zu erbringen. Auf jeden Fall sind Informationen darüber in keiner der mir zur Verfügung stehenden Fremdsprachen verfügbar. Die Unmöglichkeit einer erschöpfenden Lösung und die Merkmale der Nummer 10958 werden nachstehend ausführlicher beschrieben.

Genaue Formulierung und erste Verallgemeinerungen


Die freie Formulierung des Problems durch den Autor führte zu vielen fehlerhaften Entscheidungen, die auf einer falschen Interpretation der Bedingung beruhten. Die häufigsten Fehler:

  • Verwendung der „externen“ Verkettung: Die Kompilierung neuer Operatoren aus den Ziffern des Anfangsvektors ist zulässig, eine Verkettung in allgemeiner Form als Anhängen einer Zahl rechts von einer anderen ist jedoch verboten. Beispiele:2 | | 3 = 23 - es ist möglich,( 1 + 2 ) | | 3 = 33 - nicht erlaubt
  • Rundung: Um das Tanezhi-Problem in ganzen Zahlen zu lösen, wird nicht nur ein ganzzahliger Anfangsvektor verwendet, sondern auch ein ganzzahliges Ergebnis am Ausgang erhalten. Beispiele:8=(1−2+3)∗4 — , 7≈(1+2/3)∗4=20/3 —
  • : . : 31=(1+23)∗4−5 — , 10958 = ( 1 + 2 3 ) ∗ 3 + 4 3 + 5 ∗ 6 ∗ 7 + 8 4 + 9 4 - unmöglich

Beschreiben wir den Prozess der Überprüfung und Entscheidungsfindung des Tanezhi-Problems für eine bestimmte Anzahl. Lassen Sie für einen Vektor komplexer (im allgemeinen Fall) Zahlen( C 1 , C 2 , . . . , C k ) vorgeschlagen triple( o p , i n d , i n d + 1 ) , wobeii n d undi n d + 1 - aufeinanderfolgende natürliche Zahlen,i n d 1 < = k ;o p - Operatorcode - natürliche Zahl von 1 bis 7, dann Iteration( o p , i n d , i n d + 1 ) über dem Vektor( C 1 , C 2 , . . . , C k ) , wird ein Verfahren, das Ergebnis davon ist ein Vektor der Länge bezeichnet werdenk - 1 , nämlich:

  1. Vektor ( C 1 , C 2 , . . . , A i n d - 1 , c i n d | | c i n d + 1 , C i n d + 2 , . . . , C k ) fürÖp=1
  2. Vektor (c1,c2,...,mitichnd- -1,cichnd+cichnd+1,cichnd+2,...,ck) zum Öp=2
  3. Vektor (c1,c2,...,mitichnd- -1,|cichnd- -cichnd+1|,cichnd+2,...,ck) zum Öp=3
  4. Vektor (c1,c2,...,mitichnd- -1,cichnd∗cichnd+1,cichnd+2,...,ck) zum Öp=4
  5. Vektor (c1,c2,...,mitichnd- -1,cichnd/.cichnd+1,cichnd+2,...,ck) zum Öp=5
  6. Vektor (c1,c2,...,mitichnd- -1,ccichnd+1ichnd,cichnd+2,...,ck) zum Öp=6
  7. Vektor (c1,c2,...,mitichnd- -1,c- -(cichnd+1)ichnd,cichnd+2,...,ck) zum Öp=7

Der Anfangsvektor sei gegeben (1,2,...,9)von neun Elementen gleich ihren Seriennummern. Dann sagen sie das für eine ganze Zahlein Es gibt eine Lösung für das Tanezhi-Problem in aufsteigender Reihenfolge, wenn es eine Sequenz gibt (die wir die Ableitung für die Zahl a nennen werden):

(Öp1,ichnd1,ichnd1+1) Ist eine Iteration über den Anfangsvektor, dessen Ergebnis Vektor (1) ist
(Öp2,ichnd2,ichnd2+1)Ist eine Iteration über Vektor (1), dessen Ergebnis Vektor (2) ist
...
(Öp8,ichnd8,ichnd8+1)Ist eine Iteration über den Vektor (7), dessen Ergebnis der Vektor (8) ist,

so dass der Vektor (8) gleich dem Vektor ist(ein) jeder Vektor (- -ein) und für jede Iteration mit dem Wert des Operators gleich Eins ist es wahr, dass Elemente mit Zahlen ichndmundichndm+1werden nicht konvertiert. Wenn wir eine Iteration durchführen, werden wir ein Element eines neuen Vektors (x) als atomar bezeichnen, wenn der Wert dieses Elements dem ursprünglichen Vektor entnommen oder durch Verketten von Atomwerten erhalten wurde. Wir werden ein Element eines neuen Vektors (y) als transformiert bezeichnen, wenn es das Ergebnis einer von sechs binären arithmetischen Operationen mit Zahlen von 2 bis 7 bei einer der Iterationen vor dieser ist.

Für jeden Vektor die Anzahl der Operationen und die Möglichkeit, Wertepaare auszuwählen(ichnd,ichnd+1)begrenzt ist auch die Anzahl der Iterationen vor dem Empfang des Ergebnisses - die Anzahl a - begrenzt. Folglich gibt es eine endliche Anzahl von ganzen Zahlen, für die das Tanezhi-Problem in aufsteigender Reihenfolge eine Lösung hat. An Beispielen kann auch gezeigt werden, dass unterschiedliche Iterationssequenzen nicht immer zu unterschiedlichen Ergebnissen führen und dass nicht alle derartigen Sequenzen ein ganzes oder zumindest ein gültiges Ergebnis haben. Darüber hinaus zeigen Statistiken, insbesondere die Ergebnisse der Arbeit von Bill Ams, dass die Anzahl der verschiedenen rationalen Ausgabewerte das Doppelte der Anzahl der verschiedenen ganzzahligen Werte nicht überschreiten darf. Daher ist die erste wichtige Verallgemeinerung des Tanezhi-Problems die folgenden Fragen:

  • Wie viele verschiedene Schlussfolgerungen mit einem ganzzahligen Ergebnis gibt es?
  • Wie viele Modulo-Ganzzahlen werden ausgegeben?
  • Wie viele verschiedene komplexe Werte werden angezeigt?
  • Stimmt es, dass die Anzahl der abgeleiteten rationalen Werte und das Modulo, das eine ganze Zahl k nicht überschreitet, das Doppelte der Anzahl der verschiedenen abgeleiteten Ganzzahlen, die das Modulo k nicht überschreitet, nicht überschreitet? Für welches k? Ist es im Allgemeinen wahr?

Es ist auch wahr, dass beim Ableiten eines ganzzahligen Werts, so dass der Vektor bei einigen Zwischeniterationen irrationale und komplexe Werte enthält, die Wahrscheinlichkeit, unterschiedliche Gesamtwerte zu erhalten, abnimmt, da eine Reihe von Operationen (Hinzufügen des Irrationalen zum Rationalen, Erhöhen des Rationalen zum Irrationalen Grad) kein rationales Ergebnis zurückgeben. sondern weil die Anzahl der Optionen reduziert ist. Daher ergibt sich eine andere Verallgemeinerung:
Um zu beweisen oder zu widerlegen, dass für jede ganze Zahl a es wahr ist: Wenn das Tanezhi-Problem in aufsteigender Reihenfolge für a keine Lösung hat, in der alle Iterationen der Ausgabe an Vektoren ausgeführt werden, die keine irrationalen Elemente haben, dann hat es überhaupt keine Lösung.

Entscheidungsfortschritt


Zunächst implementieren wir die Funktion des Zählens der Anzahl aller Schlussfolgerungen, die als Lösungen für einige a betrachtet werden können - nicht unbedingt für das Ganze (d. H. Alle Schlussfolgerungen, für die die Operation mit Code 1 nur für atomare Operanden ausgeführt wird). Die Implementierungssprache ist C #.

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

Das Ergebnis des Programms:

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

Wir haben ungefähr 112 Milliarden Optionen. Konstruktionsbedingt erzeugen viele Ausgabeoptionen nicht nur den gleichen Wert, sondern haben auch die gleiche Infixdarstellung (erhalten Sie die gewünschte Anzahl mit den gleichen Operatoren auf den gleichen Operanden, aber in einer anderen Reihenfolge). Zum Beispiel, wenn die erste Iteration Elemente konvertiert1 und 2 beim 1+2=3und die zweiten Elemente 3 und 3 beim 3+3=6 und wenn die erste Iteration die Elemente konvertierte 2 und 3 beim 2+3=5und die zweiten Elemente 1 und 5 beim 1+5=6, dann erhalten wir in beiden Fällen einen Infix-Ausdruck:

1+2+3=6


Wir beschreiben einige Klassen von Schlussfolgerungen mit einer sich wiederholenden resultierenden Infix-Darstellung:

  • Lassen Sie den Additionsoperator für Operanden ausgeführt werden, von denen einer das Ergebnis der Addition ist, dann können wir uns auf Iterationen beschränken, bei denen der richtige Operand nicht das Ergebnis der Addition ist und das Ergebnis früherer Berechnungen ein Element ist, dessen Index höchstens ist ichnd+1 . 1+(2+3) (1+2)+3, 1+2+3+4∗(5+6) 5+6 1+2+3,
  • : ,
  • , 7, : (ab)c=(a−b)−, , , a−b ab
  • ( ) , .. . : a∗(b/c)=a∗b/c a/(b/c)=a/b∗c

Die Implementierung von Operatoren, die diese Klassen berücksichtigen, garantiert nicht das Fehlen von Wiederholungen zwischen Infix-Ausdrücken, aber mit BOO können Sie einige dieser Wiederholungen verwerfen.

Die Werte der Elemente der Vektoren für einige Schlussfolgerungen sind aufgrund der begrenzten Größe des Maschinenworts nicht berechenbar. Mit dem Datentyp BigInteger können einige dieser Werte berechnet werden. Deklarieren Sie die Datenstruktur für das Vektorelement. Es werden zwei lange ganze Zahlen darin sein, die den Zähler und Nenner einer rationalen Zahl darstellen. Für jeden Bediener schreiben wir eine Reihe zusätzlicher Bedingungen, die ein rationales Ergebnis ohne Überlauf gewährleisten. Durch Hinzufügen von Operationscodes und Einschränkungen für Klassen sich wiederholender Infixwerte in derselben Struktur erhalten wir die Funktion Num_1, wobei BOO die Anzahl der Schlussfolgerungen mit unterschiedlichen Infixdarstellungen zählt. Offensichtlich geht keine Lösung verloren, in dem Sinne, dass wenn für eine bestimmte Zahl a mindestens 1 Ausgabe in Num_0 vorhanden wäre,dann gibt es mindestens eine Ausgabe in Num_1 dafür.

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

Das Ergebnis des neuen Tests:

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

Erhielt ungefähr 4762 Millionen Ausdrücke.

In der Datenstruktur für das Vektorelement erstellen wir auch ein Zeichenfolgenfeld, in dem sich die Infixdarstellung der Ausgabe ansammelt. Am Ende der Iterationskette (beim rekursiven Aufrufen der Num_2-Funktion mit einem Array der Länge 1) überprüfen wir die Kontraktilität des Bruchs, der das Element dieses Vektors darstellt, und vergleichen das Ergebnis der Division des Zählers durch den Nenner mit einer bestimmten Zahl. Wenn wir die Zählervariable eingeben, erhalten wir eine Prozedur, deren Ergebnis die Anzahl der Ausgänge der Zahl val unter den gegebenen Bedingungen ist. Für Zahlen10958 und 5479=10958/.2 (Wo 5479 - einfach) wir bekommen:

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

Die Ausgabe enthält die Anzahl der Schlussfolgerungen, deren Ergebnis genau berechnet werden konnte, sowie Infix-Ausdrücke für alle Schlussfolgerungen ihrer berechneten Anzahl, die mit dem Erhalt des Werts von val endeten.

Ergebnis
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

Um den absoluten Wert ganzzahliger Grade auf nicht mehr als 27 zu begrenzen, erwiesen sich die Ergebnisse von ~ 957 Millionen Schlussfolgerungen als berechenbar, darunter 356 die Schlussfolgerungen der Zahl 5479 und keine einzige Schlussfolgerung (und dementsprechend keine einzige Schlussfolgerung mit den Operationen Addition, Subtraktion, Verkettung, Multiplikation und Division). sowie einige Schlussfolgerungen mit denselben Operationen und einigen ganzzahligen Potenzen) ist keine Schlussfolgerung der Zahl 10958. Was ist ihr Merkmal?

Geister und Schatten


Für eine Aufgabe ähnlich dem Tanezhi-Problem in aufsteigender Reihenfolge, jedoch mit Anfangsvektoren der Länge 8, wie z (1,2,...,8) und (2,3,...,9)Die Anzahl der Optionen ist geringer, und mit den irrationalen, komplexen und langen ganzzahligen Werten der Elemente der Vektoren (1) - (7) kommen optimierte Wolfram-Mathematik-Algorithmen zurecht. Es ist also zuverlässig bekannt, dass keine einzige Schlussfolgerung in(1,2,...,9), der den Verkettungs-, Additions- oder Subtraktionsoperator bei der 8. Iteration hat, kann nicht zum Wert 10958 führen. Welche Möglichkeiten bietet dies für weitere Lösungen?

Die Nummer 10958 ist halb einfach. Und wenn die letzte Iteration der Ausgabe keine Addition, Subtraktion und Verkettung enthält, wird garantiert, dass einer der Operanden bei der 8. Iteration bis zu einem gewissen Grad 5479 enthält, mit Ausnahme von zwei Fällen:

  1. wenn die Operanden Vielfache eines komplexen Konjugats sind
  2. wenn einer der Operanden einen Logarithmus enthält, dessen Basis oder Exponent ein Vielfaches von 5479 ist

Und wenn der erste Fall innerhalb der Stärke derselben Wolfram-Mathematik liegt, muss der zweite separat betrachtet werden. Bisher wurde keine einzige Schlussfolgerung gefunden, in der das Element des Ausgabevektors bei einer Iteration ein Logarithmus war, der Fall 2 erfüllt. Darüber hinaus gibt es einen allgemeinen Satz:
Satz 1: lass α=lÖGeinbwo ein und b- gegenseitig einfach. Dannα nicht über einen beliebigen Vektor ableitbar (c1,c2,...,cn) endliche Länge n, wo c1,c2,...,cn - algebraische ganze Zahlen

Ich möchte Sie daran erinnern, dass eine algebraische Ganzzahl eine beliebige Zahl ist, für die es ein Polynom mit ganzzahligen Koeffizienten und einen Einheitsführungskoeffizienten gibt, sodass eine der Wurzeln dieses Polynoms eine bestimmte Zahl ist.
Wenn es einen formalen Beweis für diesen Satz gibt, kann die Suche nach Lösungen für das Tanezhi-Problem erheblich eingeschränkt werden. Eine der Suchmethoden, mit denen Sie nur die Schlussfolgerungen überprüfen können, die am wahrscheinlichsten den gewünschten Wert erzielen, wird als "Methode der Geister und Schatten" bezeichnet und von mir vorgeschlagen.

Definition: Lassen Sie bei einer Iteration eine Schlussfolgerung über(1,2,...,9) Eines der Elemente des resultierenden Iterationsvektors ist gleich einer Primzahl p, dann wird die Infixdarstellung dieses Elements in dieser Ausgabe als Geist von p bezeichnet (1,2,...,9).

Definition: Lassen Sie bei einer Iteration eine Schlussfolgerung über(1,2,...,9) Eines der Elemente des resultierenden Vektors ist eine rationale Zahl, deren Zähler oder Nenner durch eine Primzahl p geteilt wird, und dieses Element ist kein Geist. Dann wird die Infixdarstellung dieses Elements als Schatten der Zahl p in dieser Ausgabe über bezeichnet (1,2,...,9).

Die Tabelle der Geister und Schatten für die Zahl 5479 ist hunderttausendmal kleiner als die Gesamtzahl der Schlussfolgerungen zu Num_1. Durch manuelles Kombinieren von Merkmalen mit den anderen Elementen des Ausgabe-Iterationsvektors, bei denen Geister oder Schatten gefunden wurden, können außerdem Schlussfolgerungen mit irrationalen und komplexen Graden sowie mit großen ganzzahligen und rationalen Graden erzielt werden, die in Num_2 abgeschnitten wurden. Wir beschreiben die Num_3-Funktion zum Suchen von Geistern und Schatten und fügen unserem Projekt eine Dateiausgabe hinzu.

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

Die Schlussfolgerung war umfangreich, ich werde einige seiner Abschnitte zeigen:

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

Betrachten Sie den Geist: 5479=(- -1)+((2∗(345- -6)+7)∗8). Von allen Elementen des Anfangsvektors bleiben neun unbenutzt, jedoch über dem Vektor(5479,9)irreduzibel 10958. Ebenso müssen Sie 65 Geister und 10802 Schatten analysieren. Im Internet gibt es mehrere große mathematische Gemeinschaften, die an der „Vervollständigung“ erschöpfender Probleme beteiligt sind, wie dies beim Problem der Flugzeugkacheln der Fall war. Obwohl der Satz über die Ableitbarkeit von Logarithmen mit einer für beide Seiten einfachen Basis und Argumentation nicht bewiesen wurde, besteht keine Frage einer weiteren Verfeinerung. Im nächsten Abschnitt werden wir die Frage der maschinellen Aufzählung aller Schlussfolgerungen für beliebige Vektoren endlicher Länge mit ganzzahligen algebraischen Elementen genauer untersuchen.

Diskrete Ansichten


Das Konzept einer vollständigen diskreten Darstellung


Wir alle kennen das Endlichkeitsproblem für Algorithmen, die Klasse der NP - Aufgaben, die theoretisch unbegrenzte Hardwareressourcen erfordern, um eine Lösung in linear zunehmender Zeit zu berechnen. An den Fakultäten der Informatik, an Forschungsinstituten und am Arbeitsplatz wird jedoch ein ebenso wichtiges Problem an der Schnittstelle von Programmierung und Informatik häufig ignoriert - das Problem der Repräsentierbarkeit von Daten.

Aus der Mathematik kennen wir also die rationalen Zahlen der Formein/.bwo ein und b - Coprime Naturals, darstellbar als endlicher Dezimalbruch, wenn in der kanonischen Darstellung der Zahl b Alle Primzahlen außer 2 und 5 haben ansonsten den Grad Null ein/.b kann als unendlicher Bruch dargestellt werden, der da periodisch sein wird ein/.bnicht irrational. Dann Maschinengleichheitsprüfung:

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

Hierfür gibt es verschiedene Möglichkeiten. Jede Methode stützt sich auf ihre eigene Datenstruktur und weist eine gewisse Effizienz auf. Hier sind einige Optionen:

  1. Wir verwenden zwei Gleitkommavariablen. Diese Methode hat einen offensichtlichen Vorteil: Die minimale Zeit wird für das Schreiben eines Programms aufgewendet. Indem wir jedoch nacheinander die reelle Näherung der Wurzel von 12, die reelle Näherung der Wurzel von 3/4, den Genauigkeitsverlust beim Multiplizieren von zwei reellen und noch größeren Verlusten mit der Näherungsberechnung berechnen, können wir eine reelle Zahl nahe der Wurzel der drei erhalten und den absoluten Fehler der Berechnung auswerten, um die Wahrscheinlichkeit zu bestimmen Erfüllung der Gleichheit (1)
  2. . . . , , , « ». . :
    1. 3=√α; 3=α α=√32=3
    2. : √√12∗√3/4 α=√12∗√3/4=√β; β , : β=α2=9
    3. 12∗3 4. 0, . 12∗3/4=9; , 2 3 : (1) .. 9=9

    , ,
  3. « ». : a,b,c, : (a/b)1/c : , . :

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

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

"Struktur X" ist ein gutes Beispiel für eine Datenstruktur, die eine vollständige diskrete Darstellung darstellt. Die Theorie der diskreten Darstellung irrationaler und transzendentaler Zahlen ist ein neues Gebiet der diskreten Mathematik, dem mehr Aufmerksamkeit gewidmet werden sollte.

Definition: Lassen Sie das Problem lösenUND für jeden Vektor von Eingabewerten aus einer endlichen Menge M. solche Vektoren und für einige Datenstruktur S.tructnkBeschreiben jedes Elements des Vektors als eine Menge von n natürliche Zahlen, Modulo nicht überschreiten 2len- -1wo len - die Größe des Maschinenwortes des Künstlers in Bits, wahr:

  • Algorithmus EINlGdie Aufgabe realisieren EIN in der Sprache von L wird mit der Ausgabe des korrekten Ergebnisses aufhören (entsprechend dem Ausgabeformat, eindeutig interpretiert und die Lösung des Problems EIN über einem gegebenen Vektor von Eingabewerten)
  • für jede Stufe des Alg-Algorithmus die Werte aller initialisierten Variablen vom Typ S.tructnk (Ergebnisse von Zwischenberechnungen) können eindeutig interpretiert werden, ihr numerischer Wert kann genau wiederhergestellt und verwendet werden, wenn der Algorithmus manuell verfolgt wird, während die korrekte Ausgabe beibehalten wird

dann eine formale Beschreibung S.tructnk In einigen imperativen deklarativen Programmiersprachen wird L die vollständige diskrete Darstellung (LAP) in L genannt, um das Problem A über den Satz von Vektoren der Eingabewerte von M zu lösen und zu bezeichnen: L.(EIN,M.,S.tructnk)=true

Minimaler RAP


Es gibt formale Methoden zum Aufbau von Datenstrukturen, die die RAP-Kriterien erfüllen. Eines davon: die Methode des endlichen Verschlusses. Das Schließen eines Satzes in Bezug auf einen Satz von Operationen wird als der Satz aller Zahlen betrachtet, die durch Ausführen einer endlichen Anzahl zulässiger Operationen an Elementen des ursprünglichen Satzes erhalten werden können. Beispiel: Für eine endliche Menge {0, 1} und eine Menge von Operationen: Binäre Addition und unäre Minus-Schließung sind eine MengeZ.alle ganzen Zahlen. In der Tat: um eine natürliche Zahl zu erhaltenngenug um zu falten n Einheiten zu erhalten - -n von nSie können das unäre Minus verwenden, und nicht ganzzahlige Werte werden nicht ausgegeben.

Bei der Methode des endlichen Verschlusses interessieren uns vieleM.ich alle Schaltungselemente M. viele EIN in Bezug auf eine Reihe von Operationen Öpso dass, um einen beliebigen Wert von auszugeben M.ich nicht mehr als ich Operationen von Öp über Operanden von EIN. Lassen Sie bei der Lösung eines bestimmten Problems eine Menge aller Arten von Mengen von Eingabewerten ausEINin dem der Algorithmus zum Lösen des Problems mit dem korrekten Ergebnis stoppt, dass, wenn dieser Algorithmus auf einer dieser Mengen ausgeführt wird, alle Zwischenwerte (die Werte der Variablen, die in einem Stadium des Algorithmus initialisiert wurden) liegen M.ich. Dann wird bewiesen, dass es einen MAP gibt, der aus nicht mehr als bestehtP. ganze Zahlen für ein Maschinenwort der Länge 2, wobei P. Ist die Kraft des Bulean des Sets M.ich

Für das Tanezhi-Problem ist die endgültige Verschlussmethode aufgrund der großen Größe des Buleans zum Schließen nicht anwendbar M.9In Bezug auf sieben Operationen mit dem anfänglichen Satz von Ziffern von 1 bis 9. Es stellt sich daher die Frage, die Anzahl n zu minimieren - die Anzahl der ganzzahligen Variablen, die das Element des Vektors der Zwischenwerte in einem Algorithmus beschreiben, der die Lösung des Tanezhi-Problems in aufsteigender Reihenfolge implementiert.

Definition: LetL.x - viele vollständige diskrete Darstellungen {L.(EIN,M.,S.tructnk)}} und für ein Element L.ich(EIN,M.,S.tructnich,k) (i ist die Sequenznummer des Elements der Menge) ist wahr:

  • ∀j≠ich::L.j(EIN,M.,S.tructnj,k)=true⇒nich,k⩽nj,k

dann werden wir das Element aufrufen {L.ich(EIN,M.,S.tructnich,k)}} die minimale vollständige diskrete Darstellung (LDP-Minimum) in Bezug auf L zum Lösen von Problem A über den Satz von Vektoren von Eingabewerten von M und bezeichnen: L.(michn)(EIN,M.,S.tructnk)=true

Tatsächlich ist das Tanezhi-Problem in der Form, in der es im Abschnitt „Exakter Wortlaut und erste Verallgemeinerungen“ dargestellt wird, ein vollständiges Problem der diskreten Darstellung, und die in den Ausgabesuchalgorithmen Num_2 und Num_3 verwendete NumEx-Datenstruktur ist ein Beispiel für eine Datenstruktur sogar auf einem einzigen Vektor vollständig sein (1,2,...,9). Die Konstruktion des Mindest-DAP für das Tanezhi-Problem in aufsteigender Reihenfolge ist ein wichtiger Schritt, um das Fehlen einer Schlussfolgerung für die Zahl 10958 zu beweisen.

Neue Transzendentologie


Natürlich transzendentale und genau transzendentale Zahlen


Oft erweisen sich die Konsequenzen von Theoremen, deren Beweis bei der Lösung eines bestimmten Problems erforderlich war, als wertvoller als die Aufgabe selbst. So war es mit der formalen Rechtfertigung der Unmöglichkeit, eine Quadratur eines Kreises mit einem Kompass und einem Lineal zu konstruieren, mit dem kleinen Goldbach-Problem und einer Reihe anderer mathematischer Probleme. Das passiert heute. Die Aussage über das Problem der Darstellung natürlicher Zahlen unter Verwendung von sieben Operationen auf einem bestimmten Anfangsvektor gab der Welt nicht nur schöne bestimmte Lösungen und die mysteriöse Konstante 10958, sondern auch einen speziellen Ansatz zur Klassifizierung von Größen, deren Werte nicht immer in expliziter Form geschrieben werden können. Es ist also bewiesen, dass radikale Zahlen einen Schnittpunkt ungleich Null mit der Menge der algebraischen Zahlen haben, aber in letzteren nicht vollständig enthalten sind.

Beim Schreiben von Programmen, die zwangsläufig auf die Bedingungen des Problems zurückzuführen sind, müssen Berechnungen mit Zahlen durchgeführt werden π und e Aufgrund der Qualität der Operanden sind sie normalerweise entweder durch ihre ungefähre Darstellung begrenzt oder versuchen, die analytische Berechnung der Grenze für konvergierende Reihen zu programmieren π und ebeziehungsweise. Wenn das Format für die Ausgabe des Endergebnisses des Programms und die Einzelheiten der Berechnungen die Verwendung solcher Zahlen als Symbole erlauben, fällt das Vorhandensein der transzendentalen Komponente unweigerlich in den RAP, der so minimal wie eine Variable des Attributs ist. Vergleichen Sie die beiden Datenstrukturen und die Zahlen, die sie darstellen, und bewerten Sie die Optimalität der Lösung eines bestimmten abstrakten Problems über jede dieser Strukturen:

  1. (ein,b)=ein/.b
  2. (ein,b,bp,c,cp,d)=(ein+b∗πbp+c∗ecp)/.d

Offensichtlich ist die minimale PDL im Fall von transzendentalen Zahlen möglicherweise nicht die optimale PDL in Bezug auf die Zeitkomplexität für eine Implementierung des Algorithmus in einer imperativen deklarativen Sprache.

Definition: letein1,ein2 - einige reelle algebraische Zahlen (nicht unbedingt unterschiedlich) und für einige transzendentale reelle Zahlen τ Es gibt eine Infix-Darstellung: τ=ein1Öpein2wo Öp- binärer Operator aus der Menge: Addition, Subtraktion, Multiplikation, Division, Exponentiation. Dann die Nummerτ wird 1-transzendental genannt und bezeichnet qtreinns(τ)=1

Definition: letein Ist eine echte algebraische Zahl, τk Ist eine k-transzendentale Nummer, dann werden wir eine Nummer anrufen τ (k + 1) -transzendent und bezeichnen qtreinns(τ)=k+1wenn es nicht 1-transzendental ist, 2-transzendental ... k-transzendental und es gibt eine Infix-Darstellung τ=τkÖpeinwo Öp- binärer Operator aus der Menge: Addition, Subtraktion, Multiplikation, Division, Exponentiation.

Definition: Nummerτ wird endlich transzendent genannt und bezeichnet qtreinns(τ)≠ichnf wenn für eine natürliche Zahl n Messe: qtreinns(τ)=n

Definition: Nummerτ wird exakt-transzendental genannt und bezeichnet qtreinns(τ)=ichnfwenn es gültig ist, transzendent und nicht endlich transzendent.

Mit der Einführung des Konzepts der endlichen transzendentalen Zahl wird es möglich, mit den genauen Werten einiger transzendentaler Zahlen zu arbeiten, ohne deren Symbole zu verwenden. Im Allgemeinen wird angegeben, dass es für einige Teilmengen der Menge endlicher transzendentaler Zahlen nicht leere Mengen von Problemen gibtEIN über Eingabewertvektoren bestehend aus algebraischen Zahlen, so dass für jedes Problem ab EIN Keiner der Zwischen- oder Ausgabewerte des RAP-Elements während des Betriebs des Algorithmus, der die Lösung dieses Problems aus implementiert EIN ist nicht gerade transzendent unter allen Implementierungen dieses Algorithmus in einer imperativen deklarativen Sprache L.Die Implementierung mit RAP-Minimum weist die geringste zeitliche Komplexität auf. Die Leistung der Menge A solcher Probleme hängt direkt von der Reihenfolge abqtreinns.

Tau-Ausdrücke


In der Menge der transzendentalen Zahlen kann man also in 3 disjunkte (durch Konstruktion) Teilmengen unterscheiden, deren Vereinigung mit der Menge aller transzendentalen Zahlen zusammenfällt, nämlich:

  1. endliche transzendentale Zahlen
  2. Präzision transzendentale Zahlen
  3. komplexe transzendentale Zahlen

Und wenn wir für endlich-transzendentale den RAP nach der Methode des endlichen Verschlusses konstruieren und versuchen können, ihn zu minimieren, dann für genau-transzendentale (zu denen zusätzlich zu offensichtlichen Werten π und eDer Gelfond enthält auch die Dezimallogarithmen rationaler Zahlen, die keine exakten ganzzahligen Potenzen von 10 sind, und einige andere Werte, die aus praktischer Sicht wichtig sind. Im aktuellen Abschnitt wird vorgeschlagen, eine Reihe von Zahlen zu betrachten, die sowohl endliche transzendentale als auch genau transzendentale Zahlen umfassen und einige Eigenschaften besitzen, die für die Theorie vollständiger diskreter Darstellungen wichtig sind. Es geht um eine unendliche Zahlτ-Ausdrücke (sprich: Tau-Ausdrücke) sowie einige seiner zählbaren Teilmengen.

Definition:τ-form (sprich: tau-form) erster Ordnung wird als Funktion bezeichnet τ1(α)für jedes Argument definiert α∈{0,1}} und gegeben durch die Wertetabelle: τ1(0)=e;;τ1(1)=π. Bezeichnung:qtreinnG(τ1(α))=1

Definition: τBestellform n Wir werden die Funktion aufrufen τn(α1,α2,...,αn)für jeden Vektor definiert (α1,α2,...,αn)wo αich∈{0,1}},ich=¯1,ngegeben durch eine der Gleichheiten:

  • τn(α1,α2,...,αn)=τL.(α1,α2,...,αk)+τR.EIN(αk+1,αk+2,...,αn)
  • τn(α1,α2,...,αn)=τ1(α1)τR.(α2,α3,...,αn)

Wo τ1(α) - - τFormular erster Ordnung τL.(α1,α2,...,αk) - - τBestellform kgenannt linker Major τFormen τn(α1,α2,...,αn), τR.(α2,α3,...,αn) - - τBestellform n- -1Rechtsmajor genannt τFormen τn(α1,α2,...,αn), τR.EIN(αk+1,αk+2,...,αn) - - τBestellform n- -kdie richtige Ergänzung genannt τFormen τn(α1,α2,...,αn). Bezeichnungen:qtreinnG(τn(α1,α2,...,αn))=n,L.meinj(τn(α1,α2,...,αn))=τL.(α1,α2,...,αk),R.meinj(τn(α1,α2,...,αn))=τR.(α2,α3,...,αn), R.eindd(τn(α1,α2,...,αn))=τR.EIN(αk+1,αk+2,...,αn).

ZumτFormen τn(α1,α2,...,αn) gegeben τEine Form erster Ordnung und ein rechtes Dur oder linkes Dur und ein rechtes Komplement werden betrachtet, wobei das linke Dur und das rechte Komplement oder das rechte Dur undefiniert sind.

Definition:τ-Ausdruck der Ordnung n Wir werden den Wert nennen τFormen τn(α1,α2,...,αn) Ordnung n auf einem Vektor (ein1,ein2,...,einn)genannt der treibende Vektor τ-Formen wo einich∈{0,1}},ich=¯1,n.

Wir definieren auch die Konzepte der rechten und linken Haupt- und rechten Ergänzung fürτ-Ausdrücke als Bedeutung des rechten und linken Dur bzw. des rechten Komplements τFormen τn(α1,α2,...,αn)Definieren dieses Ausdrucks auf dem entsprechenden Teilsektor des definierenden Vektors.

Beispieleτ-Ausdrücke:

π+ee;; eeπ+e+ee+e;; ππe+e;;

Definition: Hauptbegriffeτ-Ausdrücke τn der Ordnung n Art:

τn=τ1,1τk1,1+τ1,2τk2,2+
...+τ1,mτkm,m+τ1,m+1+τ1,m+2+
...+τ1,m+pwo:
τ1,ich - etwas τAusdrücke erster Ordnung ich=¯1,m+p,
τkj,j - etwas τ-Ausdrücke der Ordnung kj, j=¯1,m
und n=m+p+k1+k2+...+km
Wir werden Elemente der Form nennen:
τ1,q und τ1,rτkr,rwo q=¯m+1,m+p, r=¯1,m

Eine Möglichkeit zur Aufnahme τ-bilden:

τ(α1,α2,α3,α4,α5)=τ1(α1)τ1(α2)+τ1(α3)+τ1(α4)+τ1(α5)wo qtreinnG(τ1(α))=1

So viele τ-Ausdrücke endlicher Ordnung sind ein Sonderfall des Schließens der Menge π,ein Bezug auf Additions- und Multiplikationsoperationen. Teilmengeτ-Ausdrücke derselben Bestellung können immer bestellt werden.

Seriennummer verwendenτ-Ausdrücke als PDP ermöglicht Ihnen den Vergleich τ-Ausdrücke und führen Sie einige Operationen ohne Fehler aus, außerdem:
Satz 2. Durch Beschränkung der Reihenfolge aller Tau-Ausdrücke auf eine bestimmte Zahl n für viele Aufgaben EINFür die der RAP alle derartigen Ausdrücke darstellt, gibt es eine Implementierung L.(EINlG) in einer imperativen deklarativen Sprache L. für einige Algorithmen EINlGso dass für die Eingabezeile - Beschreibungen in jeder imperativen deklarativen Sprache L.' RAP-Datenstrukturen einer Aufgabe ein Ab A stoppt der Algorithmus mit der Ausgabe der String-Beschreibungen in der Sprache L.' RAP-Minimum für die Datenstruktur des Algorithmus L.(EINlG') - Implementierung des Algorithmus EINlG' Probleme lösen ein in der Sprache L..

In Anbetracht des Tanezhi-Problems in aufsteigender Reihenfolge ist es wichtig zu verstehen, dass keines der Elemente des Eingabe-Iterationsvektors (1), (2) und (3) transzendentale Elemente enthält (bewiesen durch Aufzählung aller solcher Iterationen). Aus der Definition der endlichen Transzendenz und auf der Grundlage des Vorstehenden folgt die Nichtabzugsfähigkeitk-Transzendentale Werte für das Tanezhi-Problem in aufsteigender Reihenfolge bei k>6. Daher beim Nachweis des Fehlens einer Schlussfolgerung für die Nummer10958 Überprüfen Sie einfach die Ableitbarkeit aller mtranszendentale Zahlen τm und algebraische Zahlen α über alle Vektorsubvektoren (1,2,...,9)so dass: 10958=τmÖpα,m<6wo Öp Ist eine Operation aus der Menge der für die Iteration (8) zulässigen durch das Tripel zulässig? (Öp,1,2). Diese Bedingung ist ausreichend: d.h. Irreduzibilität aller solcher Paare, die die Zahl darstellen10958beweist die Irreduzibilität der Zahl selbst 10958, aber das Gegenteil ist nicht wahr - von der Ausgabe bis m-transcendental folgt noch nicht der Lösung des ursprünglichen Problems.

Allgemeiner Satz "Über die Schließung endlicher Mengen transzendentaler Zahlen"


Definition: Wir werden anrufenτ-Ausdruck τnder Ordnung n normal, wenn eine der Bedingungen erfüllt ist:

  • τn numerisch gleich einem der Werte: π,e,π+e und n∈1,2
  • n>2 und rechter Major τn definiert und normal
  • n>2linker Major τn definiert und normal, richtige Ergänzung τn definierte und normale und algebraische Darstellungen des linken Dur τn und die richtige Ergänzung τn keine ähnlichen Hauptbegriffe enthalten.

Beachten Sie diese Normalität τ-Ausdrücke bedeuten im einfachen Sinne das Fehlen solcher Begriffe in der algebraischen Notation τ-Ausdrücke.

Beispiele:

πe+eπ - gut
ee+π+π+eπ+e - nicht normal, da: ee+π+π+eπ+e=ee+π+ee+π+π=2∗ee+π+π

Definition: τ-Ausdruck τ0=τn(ein1,ein2,...,einn) Wir werden die Wurzel einiger nennen τFormen τn(α1,α2,...,αn) der Ordnung nwenn dieser Ausdruck normal ist und die Ungleichung gilt:
qtreinns(τn(ein1,ein2,...,einn))⩽n,
woeinich∈{0,1}},ich=¯1,n

Satz 3. Jede zählbare Teilmenge einer Menge τ-Formen endlicher Ordnung enthalten eine endliche Zahl τ-Formen mit mindestens einer Wurzel.

Ich möchte Sie daran erinnern, dass ein Zählwert ein Satz ist, der mit dem Satz eins zu eins korrespondiert werden kann Q. ganze Zahlen.
Satz 4. Sei M. - eine bestimmte Menge reeller Zahlen, die die folgenden Bedingungen erfüllen:

  • M. natürlich oder zählbar
  • M. enthält mindestens ein genau transzendentales Element
  • Schaltkreis ¯M. viele M. in Bezug auf eine Reihe von binären Operationen: Addition und Exponentiation sind kontinuierlich

dann jede zählbare Teilmenge der Menge ¯M. enthält eine endliche Anzahl von endlichen transzendentalen Elementen.

Eine wichtige Folge von Satz 3 ist die Existenz eines MAP-Minimums für Algorithmen, die Berechnungen nur für algebraische und endlich-transzendentale Zahlen durchführen. Satz 4 gibt einen allgemeinen Überblick über die Verteilung endlicher transzendentaler Zahlen auf alle realen transzendentalen Zahlen und ist als theoretisches Werkzeug zur Klassifizierung von Gruppen, Ringen und Verschlüssen in Bezug auf Exponenten, die transzendentale Elemente enthalten, wertvoll.

Zusammenfassung


Die Theorie der endlich-transzendentalen Zahlen als Folge des Tanezhi-Problems und ein Teil des neuen mathematischen Apparats, der zur Lösung des Problems der Zahl 10958 erforderlich ist, ist ein wichtiges Werkzeug, dessen praktische Anwendung in der Programmierung und die theoretische Bedeutung für die Topologie als Wissenschaft kaum zu unterschätzen sind. Es gibt umfassende Klassifikationen rationaler, algebraischer Zahlen, komplexe Zahlen und Funktionen darüber, die detailliert untersucht wurden, und nur transzendentale Zahlen bleiben modernen Mathematikern ein Rätsel. Suche nach beliebigen WurzelnτFormulare als Übung im Laufe der Zeit werden dazu beitragen, einen neuen Ansatz zur Lösung der Probleme der Klassifizierung reeller Zahlen zu entwickeln.

Das Tanezhi-Problem selbst zeigt das Problem der vollständigen diskreten Darstellung und die Inkonsistenz gängiger Methoden zur Beschreibung der Datenstruktur bei der Lösung mathematischer Probleme auf einem PC. Für eine vollständige Aufzählung aller Schlussfolgerungen des Tanezhi-Problems über einen Vektor(1,2,...,7)Der absolute Berechnungsfehler bei Verwendung des komplexen Typs mit zwei Komponenten - Gleitkommazahlen - ermöglicht nicht die Lösung der Frage nach der Ableitbarkeit nicht nur einer bestimmten Ganzzahl, sondern auch der Frage nach der Ableitbarkeit mindestens einer Ganzzahl / rationalen Zahl aus einem kurzen Intervall.

Bei einer oberflächlichen Untersuchung des Problems der Zahl 10958 in Artikeln populärer Mathematiker wurde nur das Problem der „astronomischen Zahlen“ festgestellt - dies ist der Name von Zahlen (meistens ganze Zahlen), deren Dezimalschreibweise unmöglich ist. Lebendige Beispiele - Nummer6789das lag über dem Vektor (1,2,...,9) oder Bewertung N.≈10101034das Auftreten eines negativen Fehlers im Chebyshev-Gesetz über die Verteilung von Primzahlen. Tatsächlich können die Zwischenwerte bei der Berechnung der Ausgabe nicht nur astronomische Zahlen sein, sondern auch komplexe und transzendentale Zahlen, die Implementierung von arithmetischen Operationen, mit denen und die Berechnung von Berechnungsfehlern schwierig sind.

Einerseits bildet die populärwissenschaftliche Mathematik neue Generationen von Landwirten aus, was sich negativ auf das Image der professionellen Wissenschaft auswirkt. Andererseits führt die Aufmerksamkeit eines Multimillionen-Dollar-Publikums auf ungelöste mathematische Probleme zu vielen alternativen Ansichten über Formulierungen und mögliche Lösungen, und einige dieser Ideen bilden die Grundlage für die Arbeit professioneller Mathematiker. So war es auch mit Erdös 'Aufgabe, und so kann Inder Tanegas Amateurarbeit an den wunderbaren Darstellungen von ganzen Zahlen heute die moderne Mathematik verändern und der IT-Sphäre einen neuen Ansatz zur Beschreibung von Datenstrukturen geben.

Verweise


More articles:


All Articles