Comparando números racionais

Dado $a,b,c,d \in \mathbb N$ e ,$b,d \notin \{0\}$

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

Minhas perguntas são:

Dado$a,b,c,d$

1. Supondo que podemos decidir em , existe alguma maneira de decidir sem ter que pré-executar as multiplicações (ou divisões), e . Ou existe algum tipo de prova de que não há como.$x < y \in \mathbb Z$$\mathcal{O}(|x| +|y|)$$ad<cb$$a\cdot d$$c \cdot b$
2. Existe um método mais rápido para comparar números racionais do que multiplicar os denominadores.

Minha pesquisa atual:

Tentativa inicial de algumas regras gerais

Pode-se tentar fazer algumas regras gerais para resolver a comparação racional:

Supondo que todos os positivos :$a,b,c,d$

$$a < b \wedge c \ge d \Longrightarrow \frac a b < \frac c d\\ $$ Isso basicamente significa que, se o lado esquerdo for menor que um e o lado direito for pelo menos um, o lado esquerdo será menor que o lado direito. Na mesma veia:

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

Outra regra:

Penso nessa regra como lógica, pois quanto maior o denominador, menor o número, enquanto maior o numerador, maior o número. Portanto, se o lado esquerdo tiver um denominador maioreum numerador menor, o esquerdo será menor.

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

Daqui em diante, assumiremos que , porque, caso contrário, podemos resolvê-lo com as regras acima ou reverter a questão para $a<c \wedge b < d$ , e acabamos com essa condição de qualquer maneira.$\frac c d \overset ? < \frac a b$

Regras :

$$\left. \\ \frac {(b-a)} b < \frac {(d-c)} d \iff \left[\frac a b < \frac c d\right] \right|_{a<c,b<d} \\ $$ Essa regra basicamente afirma que você sempre pode subtrair os numeradores dos denominadores e definir os resultados como numeradores, para obter um problema equivalente. Vou deixar de fora a prova.

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

Esta regra permite subtrair o numerador e o denominador à esquerda do numerador e denominador à direita para um problema equivalente.

E é claro que há dimensionamento:

$$\left. \\ \frac {ak} {bk} < \frac {c} {d} \iff \left[\frac a b < \frac c d\right] \right|_{a<c,b<d} \\ $$ Você pode usar o dimensionamento para tornar as regras de subtração acima mais significativas.

Usando essas regras, você pode brincar com as coisas, aplicá-las repetidamente, em combinações inteligentes, mas há casos em que os números são próximos e patológicos.

Ao aplicar as regras anteriores, você pode reduzir todos esses problemas para: um

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

Às vezes você pode resolver isso diretamente agora, às vezes não. Os casos patológicos geralmente estão na forma:

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

Então você vira e resulta na mesma coisa, apenas com um pouco menos. Cada aplicação das regras + flip reduz em um dígito / bit. AFAICT, você não pode resolvê-lo rapidamente, a menos que aplique as regras vezes (uma vez para cada dígito / bit) no caso patológico, negando sua aparente vantagem.$\mathcal O(n)$

Problema em aberto ??

Percebi que esse problema parece ser mais difícil do que alguns problemas atuais em aberto.

Um problema ainda mais fraco é determinar:

$$ad \overset ? = bc$$

E ainda mais fraco:

$$ad \overset ? = c$$

Esse é o problema aberto de verificação da multiplicação . É mais fraco, porque se você tivesse uma maneira de determinar , então você pode facilmente determinar a d ? = b c , testando usando o algoritmo duas vezes, a d ? < b c , b c ? < a d . Iff tanto é verdade, você sabe que um d ≠ b c .$ad \overset ? < bc$$ad \overset ? = bc$$ad \overset ? < bc$$bc \overset ? < ad$$ad \ne bc$

Agora, era um problema em aberto, pelo menos em 1986:$ad \overset ? = c$

A complexidade da multiplicação e divisão. Vamos começar com a equação muito simples ax = b. Quando considerado sobre os números inteiros, é possível testar sua solvabilidade e encontrar uma solução x pela divisão inteira com o restante zero. Para verificar uma determinada solução x, a multiplicação inteira será suficiente, mas é um problema em aberto interessante se existem métodos mais rápidos de verificação.

- ARNOLD SCHÖNHAGE na resolução de equações em termos de complexidade computacional

Muito interessante, ele também mencionou a questão de verificar a multiplicação da matriz :

Também é uma questão interessante se a verificação da multiplicação da matriz, ou seja, verificar se AB = G para um dado C, poderia ser feita mais rapidamente.

- ARNOLD SCHÖNHAGE na resolução de equações em termos de complexidade computacional

Isso já foi resolvido e é realmente possível verificar em tempo com um algoritmo aleatório (com n × n sendo o tamanho das matrizes de entrada, portanto, é basicamente o tempo linear no tamanho da entrada ) Gostaria de saber se é possível reduzir a multiplicação inteira à multiplicação de matrizes, especialmente com suas semelhanças, dadas as semelhanças da multiplicação inteira de Karatsuba com os algoritmos de multiplicação de matrizes que se seguiram. Então, talvez, de alguma forma, possamos alavancar o algoritmo de verificação de multiplicação de matrizes para multiplicação de números inteiros.$\mathcal O(n^2)$$n\times n$

Enfim, uma vez que este ainda é, que eu saiba, um problema aberto, o problema mais forte de está certamente aberto. Estou curioso para saber se a solução do problema de verificação de igualdade teria alguma influência no problema de verificação de desigualdade de comparação.$ad \overset ? < cd$

Uma pequena variação do nosso problema seria se as frações fossem reduzidas aos termos mais baixos; Nesse caso, é fácil saber se . Isso pode ter alguma influência na verificação comparativa de frações reduzidas?$\frac a b \overset ? = \frac c d$

Uma pergunta ainda mais sutil, e se tivéssemos uma maneira de testar , seria este estender-se a testar um d ? = c ? Não vejo como você pode usar isso "nos dois sentidos", como fizemos para um d ? < c d .$ad \overset ? < c$$ad \overset ? = c$$ad \overset ? < cd$

Palavras-chave:

• Reconhecimento aproximado de idiomas não regulares por autômatos finitos

  Eles trabalham na multiplicação aproximada e na verificação aleatória, que eu não entendo completamente.

• math.SE: Como comparar duas multiplicações sem multiplicar?
• Suponha que tenhamos permissão para pré-processar quanto desejássemos no tempo polinomial, podemos resolver a b = c no tempo linear?$c$$ab=c$
• Existe um algoritmo de multiplicação de números inteiros não-determinísticos em tempo linear? Consulte http://compgroups.net/comp.theory/nondeterministic-linear-time-multiplication/1129399

  Existem algoritmos conhecidos para multiplicar números de n bits com algo como complexidade O (n log (n) log (log (n))). E não podemos fazer melhor que O (n) porque pelo menos temos que olhar para todas as entradas. Minha pergunta é: podemos realmente alcançar O (n) para uma classe adequada de algoritmos "não determinísticos"?

  Mais precisamente, existe um algoritmo que pode aceitar dois números binários de n bits "a" e "b" e um número de 2n bits "c" e informar em O (n) tempo se "a * b = c"? Caso contrário, existe alguma outra forma de certificado C (a, b, c) tal que um algoritmo possa usá-lo para testar o produto em tempo linear? Se não for tempo linear, o problema de testar o produto é pelo menos assintoticamente mais fácil do que calculá-lo? Quaisquer resultados conhecidos nesse sentido seriam bem-vindos.

  John.

  ―Johnh4717

Aqui está uma tentativa muito parcial de reprovação. Suponha-se que pode fazer uso de uma única (número constante de) adições e subtracções em nosso decisor, bem como um número constante de wrt predefinido números. Em outras palavras, podemos fazer um número constante de m o d 2 , m o d 3 , etc, em nosso decisor. Então as únicas quantidades que podemos calcular são da forma q = k 1 a + k 2 b + k 3 c + k 4 d = ∑ ${mod}$$mod\ 2$$mod\ 3$ onde o k s' são predefinidos constantes. Note que q pode ser calculado no tempo O ( ∑ | a | ) .$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,$

(Como tornar isso mais preciso?) A distância do cuboide à superfície é geralmente ilimitada e, portanto, a superfície não pode ser calculada pelo decisor

Boa pergunta. Você aceitaria nível de confiança?

Talvez faça divisão aproximada. Ou seja,

Para calcular os quocientes aproximados delimitadores de a / b, mova à direita a pelo teto (log_2 (b)) e também pelo piso (log_2 (b)). Então, sabemos que o quociente exato está entre esses dois valores.

Então, dependendo dos tamanhos relativos dos quatro números inteiros, é possível descartar certos casos e obter 100% de confiança.

Pode-se repetir o procedimento para radix diferente de 2 e, por uma sucessão de tais operações, aumentar o nível de confiança, até que uma mudança de sinal / desempate seja observada de alguma forma?

Esse é o meu primeiro rascunho de um método.

existe alguma maneira de decidir ad <cb sem ter que pré-formar as multiplicações [caras]

Certo.

Idéia: compare a expansão decimal pouco a pouco.

A única parte desagradável é que temos que excluir a igualdade primeiro porque, caso contrário, não podemos terminar.
É útil comparar primeiro as partes inteiras, porque isso é fácil.

Considere isto:

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
}

Observe que o do-whileloop precisa terminar, pois os números são desiguais. Porém, não sabemos quanto tempo isso dura; se os números estiverem muito próximos, pode demorar um pouco.

$10$$ad$$cb$

Isso é rápido? Provavelmente não. Existem muitas divisões inteiras, módulos gdces para calcular, e temos um loop cujo número de iterações é inversamente proporcional à distância entre os números que comparamos.

---

O método auxiliar:

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