Comparaison des nombres rationnels

Étant donné et b , d ∉ { 0 } ,$a,b,c,d \in \mathbb N$$b,d \notin \{0\}$

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

Mes questions sont:

Étant donné $a,b,c,d$

1. En supposant que nous pouvons décider dans O ( | x | + | y | ) , existe-t-il un moyen de décider a d < c b sans avoir à préformer les multiplications (ou divisions), a ⋅ d et c ⋅ b . Ou existe-t-il une sorte de preuve qu'il n'y a aucun moyen.$x < y \in \mathbb Z$$\mathcal{O}(|x| +|y|)$$ad<cb$$a\cdot d$$c \cdot b$
2. Existe-t-il une méthode plus rapide pour comparer les nombres rationnels que de multiplier les dénominateurs.

Mes recherches actuelles:

Tentative initiale de quelques règles générales

On peut essayer de faire quelques règles générales pour résoudre la comparaison rationnelle:

En supposant tous positifs :$a,b,c,d$

$$a < b \wedge c \ge d \Longrightarrow \frac a b < \frac c d\\ $$ Cela signifie essentiellement que si le côté gauche est inférieur à un et que le côté droit en est au moins un, le côté gauche est inférieur au côté droit. Dans la même veine:

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

Une autre règle:

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

$a<c \wedge b < d$$\frac c d \overset ? < \frac a b$

Règles :

$$\left. \\ \frac {(b-a)} b < \frac {(d-c)} d \iff \left[\frac a b < \frac c d\right] \right|_{a<c,b<d} \\ $$ Cette règle indique essentiellement que vous pouvez toujours soustraire les numérateurs des dénominateurs et définir les résultats comme numérateurs pour obtenir un problème équivalent. Je laisse de côté la preuve.

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

Cette règle vous permet de soustraire le numérateur et le dénominateur gauche du numérateur et du dénominateur droit pour un problème équivalent.

Et bien sûr, il y a la mise à l'échelle:

$$\left. \\ \frac {ak} {bk} < \frac {c} {d} \iff \left[\frac a b < \frac c d\right] \right|_{a<c,b<d} \\ $$ Vous pouvez utiliser la mise à l'échelle pour rendre les règles de soustraction ci-dessus plus significatives.

En utilisant ces règles, vous pouvez jouer avec les choses, les appliquer à plusieurs reprises, dans des combinaisons intelligentes, mais il y a des cas où les nombres sont proches et pathologiques.

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

Parfois, vous pouvez résoudre ce problème directement maintenant, parfois non. Les cas pathologiques se présentent généralement sous la forme:

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

$\mathcal O(n)$

Problème ouvert ??

J'ai réalisé que ce problème semble être plus difficile que certains problèmes ouverts actuels.

Un problème encore plus faible consiste à déterminer:

$$ad \overset ? = bc$$

Et pourtant plus faible:

$$ad \overset ? = c$$

$ad \overset ? < bc$$ad \overset ? = bc$$ad \overset ? < bc$$bc \overset ? < ad$$ad \ne bc$

$ad \overset ? = c$

La complexité de la multiplication et de la division. Commençons par l'équation très simple ax = b. Lorsqu'on le considère sur les entiers, tester sa solvabilité et trouver une solution x est possible par division entière avec le reste zéro. Pour vérifier une solution donnée x, une multiplication entière suffira, mais c'est un problème ouvert intéressant de savoir s'il existe des méthodes de vérification plus rapides.

- ARNOLD SCHÖNHAGE en résolution d'équations en termes de complexité informatique

Très intéressant, il a également évoqué la question de la vérification de la multiplication matricielle :

Il est également intéressant de savoir si la vérification de la multiplication matricielle, c'est-à-dire la vérification si AB = G pour un C donné, pourrait être effectuée plus rapidement.

- ARNOLD SCHÖNHAGE en résolution d'équations en termes de complexité informatique

$\mathcal O(n^2)$$n\times n$

$ad \overset ? < cd$

$\frac a b \overset ? = \frac c d$

$ad \overset ? < c$$ad \overset ? = c$$ad \overset ? < cd$

En relation:

• Reconnaissance approximative des langues non régulières par les automates finis

  Ils font un travail sur la multiplication approximative et la vérification aléatoire, ce que je ne comprends pas complètement.

• math.SE: Comment comparer deux multiplications sans multiplier?
• $c$$ab=c$
• Existe-t-il un algorithme de multiplication d'entiers non déterministes en temps linéaire? Voir http://compgroups.net/comp.theory/nondeterministic-linear-time-multiplication/1129399

  Il existe des algorithmes bien connus pour multiplier les nombres à n bits avec quelque chose comme la complexité O (n log (n) log (log (n))). Et nous ne pouvons pas faire mieux que O (n) car au moins nous devons regarder l'ensemble des entrées. Ma question est: pouvons-nous réellement atteindre O (n) pour une classe appropriée d'algorithmes "non déterministes"?

  Plus précisément, existe-t-il un algorithme qui peut accepter deux nombres binaires à n bits "a" et "b" et un nombre à 2n bits "c" et vous dire en temps O (n) si "a * b = c"? Sinon, existe-t-il une autre forme de certificat C (a, b, c) telle qu'un algorithme puisse l'utiliser pour tester le produit en temps linéaire? S'il n'est pas linéaire, le problème de tester le produit est-il au moins asymptotiquement plus facile que de le calculer? Tout résultat connu dans ce sens serait le bienvenu.

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

(Comment rendre cela plus précis?) La distance du cuboïde à la surface est en général illimitée, et donc la surface ne peut pas être calculée par le décideur

Bonne question. Accepteriez-vous le niveau de confiance?

Faites peut-être une division approximative. C'est à dire

Pour calculer les quotients approximatifs englobants de a / b, décaler vers la droite a par plafond (log_2 (b)) et également par étage (log_2 (b)). Nous savons alors que le quotient précis se situe entre ces deux valeurs.

Ensuite, selon la taille relative des quatre entiers, on peut être en mesure d'exclure certains cas et d'obtenir une confiance de 100%.

On peut répéter la procédure pour radix autre que 2, et par une succession de telles opérations augmenter le niveau de confiance, jusqu'à ce qu'un changement de signe / tie-break soit observé d'une manière ou d'une autre?

C'est ma première esquisse d'une méthode.

existe-t-il un moyen de décider ad <cb sans avoir à préformer les multiplications [coûteuses]

Sûr.

Idée: Comparez l'expansion décimale bit par bit.

Le seul élément désagréable est que nous devons d'abord exclure l'égalité car sinon nous ne pourrions pas y mettre fin.
Il est utile de comparer d'abord les parties entières car c'est facile.

Considère ceci:

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
}

Notez que la do-whileboucle doit se terminer car les nombres sont inégaux. Nous ne savons cependant pas combien de temps cela dure; si les chiffres sont très proches, cela pourrait prendre un certain temps.

$10$$ad$$cb$

Est-ce rapide? Probablement pas. Il existe de nombreuses divisions entières, modules et gdcs à calculer, et nous avons une boucle dont le nombre d'itérations est inversement proportionnel à la distance entre les nombres que nous comparons.

---

La méthode d'assistance:

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