Rationale Zahlen vergleichen

Gegeben $a,b,c,d \in \mathbb N$ und $b,d \notin \{0\}$ ,

$$\begin{eqnarray*} \frac a b < \frac c d &\iff& ad < cb \end{eqnarray*}$$

Meine Fragen sind:

Gegeben $a,b,c,d$

1. Angenommen, wir können in , gibt es eine Möglichkeit, zu bestimmen, ohne die Multiplikationen (oder Divisionen), und . Oder gibt es einen Beweis dafür, dass es keinen Weg gibt?$x < y \in \mathbb Z$$\mathcal{O}(|x| +|y|)$$ad<cb$$a\cdot d$$c \cdot b$
2. Gibt es eine schnellere Methode, um rationale Zahlen zu vergleichen, als die Nenner zu multiplizieren?

Meine aktuelle Forschung:

Erster Versuch mit einigen allgemeinen Regeln

Man kann versuchen, einige allgemeine Regeln für die Lösung des rationalen Vergleichs aufzustellen:

Angenommen, alle positiven :$a,b,c,d$

$$a < b \wedge c \ge d \Longrightarrow \frac a b < \frac c d\\ $$ Dies bedeutet im Grunde, wenn die linke Seite kleiner als eins ist und die rechte Seite mindestens eins ist, ist die linke Seite kleiner als die rechte Seite. In der gleichen Richtung:

$$a \ge b \wedge c \le d \Longrightarrow \frac a b \not\lt \frac c d\\ $$

Eine andere Regel:

Ich halte diese Regel für logisch, denn je größer der Nenner, desto kleiner die Zahl, und je größer der Zähler, desto größer die Zahl. Wenn also die linke Seite einen größeren Nennerundeinen kleineren Zähler hat, ist die linke Seite kleiner.

$$(b > d) \wedge (a \le c) \Rightarrow \left[\frac a b < \frac c d\right]$$

Ab jetzt nehmen wir an, dass , da wir es sonst entweder mit den obigen Regeln lösen oder die Frage in c umkehren können$a<c \wedge b < d$ , und wir haben sowieso diese Bedingung.$\frac c d \overset ? < \frac a b$

Regeln :

$$\left. \\ \frac {(b-a)} b < \frac {(d-c)} d \iff \left[\frac a b < \frac c d\right] \right|_{a<c,b<d} \\ $$ Diese Regel besagt grundsätzlich, dass Sie die Zähler immer von den Nennern abziehen und die Ergebnisse als Zähler festlegen können, um ein gleichwertiges Problem zu erhalten. Ich werde den Beweis weglassen.

$$\left. \\ \frac {a} b < \frac {c-a} {d-b} \iff \left[\frac a b < \frac c d\right] \right|_{a<c,b<d} \\ $$

Mit dieser Regel können Sie den linken Zähler und Nenner vom rechten Zähler und Nenner für ein gleichwertiges Problem abziehen.

Und natürlich gibt es Skalierung:

$$\left. \\ \frac {ak} {bk} < \frac {c} {d} \iff \left[\frac a b < \frac c d\right] \right|_{a<c,b<d} \\ $$ Sie können die Skalierung verwenden, um die obigen Subtraktionsregeln signifikanter zu machen.

Mithilfe dieser Regeln können Sie mit Dingen herumspielen, sie wiederholt in intelligenten Kombinationen anwenden, aber es gibt Fälle, in denen Zahlen nahe beieinander liegen und pathologisch sind.

Durch Anwenden der vorherigen Regeln können Sie all diese Probleme auf Folgendes reduzieren: a

$$\left. \frac a b < \frac {ap+q} {bp'+q'} \iff \frac a b < \frac {q} {q'} \right|_{a>q,b>q'}$$

Manchmal kann man das jetzt direkt lösen, manchmal nicht. Die pathologischen Fälle sind in der Regel in der Form:

$$\left. \frac a b < \frac {c} {d} \right|_{a>c,b>d,c\in \mathcal O(a), d \in \mathcal O(b)}$$

Dann drehen Sie es um und erhalten dasselbe Ergebnis, nur mit einem bisschen weniger. Jede Anwendung der Regeln + Flip reduziert sie um eine Ziffer / Bit. AFAICT, Sie können es nicht schnell lösen, es sei denn, Sie wenden die Regeln mal (einmal für jede Ziffer / Bit) im pathologischen Fall an und negieren ihren scheinbaren Vorteil.$\mathcal O(n)$

Offenes Problem?

Mir wurde klar, dass dieses Problem schwieriger zu sein scheint als einige derzeit offene Probleme.

Ein noch schwächeres Problem besteht darin, festzustellen:

$$ad \overset ? = bc$$

Und doch schwächer:

$$ad \overset ? = c$$

Dies ist das offene Problem der Überprüfung der Multiplikation . Es ist schwächer, denn wenn du einen Weg hättest, zu bestimmen ? < b c , dann können Sie leicht ein d bestimmen ? = b c , durch zweimaliges Testen mit dem Algorithmus, a d ? < b c , b c ? < a d . Wenn beides zutrifft, wissen Sie, dass a d ≠ b c .$ad \overset ? < bc$$ad \overset ? = bc$$ad \overset ? < bc$$bc \overset ? < ad$$ad \ne bc$

Nun, war zumindest 1986 ein offenes Problem:$ad \overset ? = c$

Die Komplexität von Multiplikation und Division. Beginnen wir mit der sehr einfachen Gleichung ax = b. Über die ganzen Zahlen betrachtet ist es möglich, die Lösbarkeit zu testen und eine Lösung x durch ganzzahlige Division mit dem Rest Null zu finden. Für die Überprüfung einer gegebenen Lösung x reicht die ganzzahlige Multiplikation aus, aber es ist ein interessantes offenes Problem, ob es schnellere Überprüfungsmethoden gibt.

- ARNOLD SCHÖNHAGE beim Lösen von Gleichungen in Bezug auf die Komplexität von Rechnern

Sehr interessanterweise erwähnte er auch die Frage der Überprüfung der Matrixmultiplikation :

Es ist auch eine interessante Frage, ob die Überprüfung der Matrixmultiplikation, dh die Überprüfung, ob für gegebenes C AB = G ist, möglicherweise schneller durchgeführt werden könnte.

- ARNOLD SCHÖNHAGE beim Lösen von Gleichungen in Bezug auf die Komplexität von Rechnern

Dies ist seitdem gelöst worden, und es ist tatsächlich möglich, in -Zeit mit einem zufälligen Algorithmus zu verifizieren (wobei n × n die Größe der Eingabematrizen ist, so dass es sich im Grunde genommen um eine lineare Zeit in der Größe der Eingabe handelt ). Ich frage mich, ob es möglich ist, die Ganzzahlmultiplikation auf die Matrixmultiplikation zu reduzieren, insbesondere aufgrund ihrer Ähnlichkeiten, da die Ganzzahlmultiplikation von Karatsuba Ähnlichkeiten mit den nachfolgenden Matrixmultiplikationsalgorithmen aufweist. Dann können wir vielleicht auf irgendeine Weise den Matrixmultiplikations-Verifizierungsalgorithmus für die ganzzahlige Multiplikation nutzen.$\mathcal O(n^2)$$n\times n$

Wie auch immer, da dies meines Wissens immer noch ein offenes Problem ist, das stärkere Problem ist sicherlich offen. Ich bin gespannt, ob die Lösung des Problems der Überprüfung der Gleichheit einen Einfluss auf das Problem der Überprüfung der Vergleichsungleichheit hat.$ad \overset ? < cd$

Eine geringfügige Abweichung von unserem Problem wäre, wenn die Brüche garantiert auf die niedrigsten Werte reduziert werden; In diesem Fall ist es leicht zu erkennen, ob . Kann dies einen Einfluss auf die Vergleichsprüfung für reduzierte Brüche haben?$\frac a b \overset ? = \frac c d$

Eine noch subtilere Frage: Was wäre, wenn wir einen Weg hätten, zu testen ? < c , würde sich dies auf das Testen eines d erstrecken ? = c ? Ich verstehe nicht, wie Sie diese "beiden Möglichkeiten" nutzen können, wie wir es für ein d getan haben ? < c d .$ad \overset ? < c$$ad \overset ? = c$$ad \overset ? < cd$

Verbunden:

• Ungefähre Erkennung von nicht regulären Sprachen durch endliche Automaten

  Sie arbeiten an der ungefähren Multiplikation und der randomisierten Verifikation, die ich nicht vollständig verstehe.

• math.SE: Wie kann man zwei Multiplikationen ohne Multiplikation vergleichen?
• Angenommen, wir durften in der Polynomzeit so weit vorverarbeiten, wie wir wollten. Können wir a b = c in linearer Zeit lösen ?$c$$ab=c$
• Gibt es einen linearen nichtdetermistischen Ganzzahl-Multiplikationsalgorithmus? Siehe http://compgroups.net/comp.theory/nondeterministic-linear-time-multiplication/1129399

  Es gibt bekannte Algorithmen zum Multiplizieren von n-Bit-Zahlen mit so etwas wie der Komplexität von O (n log (n) log (log (n)). Und wir können es nicht besser machen als O (n), weil wir uns zumindest die gesamten Eingaben ansehen müssen. Meine Frage ist: Können wir tatsächlich O (n) für eine geeignete Klasse von "nicht deterministischen" Algorithmen erreichen?

  Genauer gesagt, gibt es einen Algorithmus, der zwei n-Bit-Binärzahlen "a" und "b" und eine 2n-Bit-Zahl "c" akzeptieren und Ihnen in O (n) -Zeit mitteilen kann, ob "a * b = c" ist? Wenn nicht, gibt es eine andere Form von Zertifikat C (a, b, c), mit der ein Algorithmus das Produkt in linearer Zeit testen kann? Wenn nicht die lineare Zeit, ist es dann einfacher, das Produkt zumindest asymptotisch zu testen, als es zu berechnen? Alle bekannten Ergebnisse in dieser Richtung wären willkommen.

  John.

  ―Johnh4717

${mod}$$mod\ 2$$mod\ 3$$q = k_1 a +k_2 b+k_3 c + k_4 d = \sum k_ia$$k$$q$$O(\sum|a|)$

$B:B=1$$ad>bc$$a,b,c,d$$\mathbb{R}^4$$B$$ad = bc$$(a,b,c,d)$$q: |q-a| = k_1,$

(Wie kann man das präzisieren?) Der Abstand vom Quader zur Oberfläche ist im Allgemeinen unbegrenzt, und daher kann die Oberfläche vom Entscheider nicht berechnet werden

Gute Frage. Würden Sie ein gewisses Maß an Vertrauen akzeptieren?

Vielleicht eine ungefähre Aufteilung machen. Dh

Um die ungefähren Grenzquotienten von a / b zu berechnen, verschieben Sie a nach rechts um ceil (log_2 (b)) und auch um floor (log_2 (b)). Dann wissen wir, dass der genaue Quotient zwischen diesen beiden Werten liegt.

Abhängig von der relativen Größe der vier Ganzzahlen kann man dann bestimmte Fälle ausschließen und 100% iges Vertrauen erhalten.

Man kann die Prozedur für radix anders als 2 wiederholen und durch eine Abfolge solcher Operationen das Vertrauensniveau erhöhen, bis ein Wechsel des Vorzeichens / Gleichstandes irgendwie beobachtet wird?

Das ist meine erste Skizze einer Methode.

Gibt es eine Möglichkeit, ad <cb zu bestimmen, ohne die [teuren] Multiplikationen durchführen zu müssen?

Sicher.

Idee: Vergleichen Sie die Dezimalerweiterung nach und nach.

Das einzig schlimme ist, dass wir zuerst die Gleichheit ausschließen müssen, da wir sonst möglicherweise nicht kündigen.
Es ist nützlich, zuerst die ganzzahligen Teile zu vergleichen, da dies einfach ist.

Bedenken Sie:

def less( (a,b), (c,d) ) = {
  // Compare integer parts first
  intA = a div b
  intC = c div d

  if intA < intB
    return True
  else if intA > intB
    return False
  else // intA == intB
    // Normalize to a number in [0,1]
    a = a mod b
    c = c mod d

    // Check for equality by reducing both
    // fractions to lowest terms
    (a,b) = lowestTerms(a,b)
    (c,d) = lowestTerms(c,d)

    if a == c and b == d
      return False
    else
      do
        // Compute next digits in decimal fraction 
        a = 10 * a
        c = 10 * c

        intA = a div b
        intC = c div d

        // Remove integer part again
        a = a mod b
        c = c mod d
      while intA == intC

      return intA < intC
    end
  end
}

Notiere dass der do-while Schleife beendet werden muss, da die Zahlen ungleich sind. Wir wissen jedoch nicht, wie lange es dauert; Wenn die Zahlen sehr nahe sind, könnte es eine Weile dauern.

Natürlich gibt es keine teuren Multiplikationen; Wir müssen nur die Nominatoren mit multiplizieren$10$. Insbesondere haben wir das Rechnen vermieden $ad$ und $cb$ ausdrücklich.

Ist das schnell? Wahrscheinlich nicht. Es gibt viele ganzzahlige Divisionen, Module und gdcs zu berechnen, und wir haben eine Schleife, deren Anzahl der Iterationen umgekehrt proportional zum Abstand zwischen den Zahlen ist, die wir vergleichen.

---

Die Hilfsmethode:

def lowestTerms(a,b) = {
  d = gcd(a,b)
  if d == 1
    return (a,b)
  else
    return lowestTerms(a div d, b div d)
  end
}