Rasyonel sayıları karşılaştırma

ve verildiğinde , 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*}$$

Sorularım:

Verilen$a,b,c,d$

1. Karar varsayarak de , karar verme herhangi bir yolu yoktur çarpma (ya da bölümler), preform zorunda kalmadan ve . Yoksa yolu olmadığını gösteren bir tür kanıt var mı?O ( | x | + | y | ) a d < c b a ⋅ d c ⋅ $x < y \in \mathbb Z$$\mathcal{O}(|x| +|y|)$$ad<cb$$a\cdot d$$c \cdot b$
2. Rasyonel sayıları karşılaştırmak için paydaları çarpmaktan daha hızlı bir yöntem var mı?

Mevcut araştırmam:

Bazı genel kurallarda ilk deneme

Rasyonel karşılaştırmayı çözmek için bazı genel kurallar yapmaya çalışılabilir:

Tüm pozitif varsayarsak :$a,b,c,d$

$$a < b \wedge c \ge d \Longrightarrow \frac a b < \frac c d\\ $$ Bu, temel olarak, sol taraf birden az ve sağ taraf en az bir ise, sol taraf sağdan daha az demektir yan. Aynı damarda:

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

Başka bir kural:

$$(b > d) \wedge (a \le c) \Rightarrow \left[\frac a b < \frac c d\right]$$ Bu kuralı mantıklı buluyorum, çünkü payda sayı küçüldükçe pay, sayı ne kadar büyük olursa. Bu nedenle, sol tarafta daha büyük bir payda ve daha küçük bir pay varsa, sol daha küçük olacaktır.

Buradan itibaren, olduğunu varsayacağız, aksi takdirde yukarıdaki kurallarla çözebiliriz veya soruyu , ve biz yine de bu koşulla sonuçlanır.$a<c \wedge b < d$$\frac c d \overset ? < \frac a b$

Kurallar : Bu kuralı temel olarak, eşdeğer bir sorun elde etmek için payları her zaman paydalardan çıkarabileceğinizi ve sonuçları pay olarak ayarlayabileceğinizi belirtir. Kanıtı dışarıda bırakacağım.

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

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

Bu kural, eşdeğer bir sorun için sol payı ve paydayı sağ paydan ve paydadan çıkarmanızı sağlar.

Ve elbette ölçeklendirme var:

$$\left. \\ \frac {ak} {bk} < \frac {c} {d} \iff \left[\frac a b < \frac c d\right] \right|_{a<c,b<d} \\ $$ You yukarıdaki çıkarma kurallarını daha anlamlı hale getirmek için ölçeklemeyi kullanabilir.

Bu kuralları kullanarak, şeylerle oynayabilir, tekrar tekrar, akıllı kombinasyonlarda uygulayabilirsiniz, ancak sayıların yakın ve patolojik olduğu durumlar vardır.

Önceki kuralları uygulayarak, tüm bu sorunları şu şekilde azaltabilirsiniz:

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

Bazen bunu doğrudan çözebilirsin, bazen çözemezsin. Patolojik vakalar genellikle formdadır:

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

Sonra çevirirsiniz ve aynı şeyle sonuçlanırsınız, sadece bir parça daha az. Her kural + flip uygulaması onu bir rakam / bit azaltır. AFAICT, patolojik durumda kez (her basamak / bit için bir kez uygulamadığınız sürece , görünüşte avantajlarını reddeden hızlı bir şekilde çözemezsiniz .$\mathcal O(n)$

Açık problem ??

Bu sorunun bazı açık problemlerden daha zor göründüğünü fark ettim.

Daha da zayıf bir problem aşağıdakileri belirlemektir:

$$ad \overset ? = bc$$

Ve yine de daha zayıf:

$$ad \overset ? = c$$

Bu, çarpmayı doğrulamanın açık problemidir . Zayıf, çünkü belirlemenin bir yolu olsaydı , o zaman kolayca belirleyebilirsiniz , algoritmayı iki kez kullanarak test ederek , . Iff ya da doğruysa, .$ad \overset ? < bc$$ad \overset ? = bc$$ad \overset ? < bc$$bc \overset ? < ad$$ad \ne bc$

Şimdi, en azından 1986'da açık bir sorundu:$ad \overset ? = c$

Çarpma ve bölmenin karmaşıklığı. Çok basit bir denklem baltası = b ile başlayalım. Tamsayılar üzerinde ele alındığında, çözülebilirliğini test etmek ve bir çözelti bulmak x sıfır kalan tamsayı bölme ile mümkündür. Belirli bir çözümü x kontrol etmek için, tamsayı çarpımı yeterli olacaktır, ancak daha hızlı doğrulama yöntemleri olup olmadığı ilginç bir açık sorundur.

- Hesaplama Karmaşıklığı Açısından Denklem Çözmede ARNOLD SCHÖNHAGE

Çok ilginç bir şekilde, matris çarpımını doğrulama sorusundan da bahsetti :

Matris çarpımının doğrulanmasının, yani verilen C için AB = G'nin muhtemelen daha hızlı yapıp yapamayacağını kontrol etmek de ilginç bir sorudur.

- Hesaplama Karmaşıklığı Açısından Denklem Çözmede ARNOLD SCHÖNHAGE

Bu çözüldüğünden beri, ve zamanında rastgele bir algoritma ile doğrulamak mümkündür ( , giriş matrislerinin büyüklüğüdür, bu nedenle temelde doğrusal giriş boyutu). Merak ediyorum, Karatsuba tamsayı çarpımının takip eden matris çarpma algoritmalarına benzerlikleri düşünüldüğünde, özellikle benzerlikleriyle tamsayı çarpımını matris çarpımına indirmenin mümkün olup olmadığını merak ediyorum. O zaman belki de bir şekilde tamsayı çarpımı için matris çarpma doğrulama algoritmasından yararlanabiliriz.$\mathcal O(n^2)$$n\times n$

Her neyse, bu hala bildiğim kadarıyla, açık bir sorun, daha güçlü sorunu var kesinlikle açık. Eşitlik doğrulama sorununun çözülmesinin karşılaştırma eşitsizliği doğrulama sorunu üzerinde herhangi bir etkisi olup olmadığını merak ediyorum.$ad \overset ? < cd$

Kesirlerimizin en düşük terimlere indirgeneceği garanti edilirse, sorunumuzda ufak bir değişiklik olur; bu durumda olup olmadığını söylemek kolaydır . Bunun azaltılmış kesirler için karşılaştırma doğrulamasına etkisi olabilir mi?$\frac a b \overset ? = \frac c d$

Daha da hassas bir soru, test etmenin bir yolu olsaydı ne olurdu , bu test etmeye kadar uzanır ? için yaptığımız gibi bu "her iki yolu" nasıl kullanabileceğinizi görmüyorum .$ad \overset ? < c$$ad \overset ? = c$$ad \overset ? < cd$

İlişkili:

• Sonlu Otomata ile Düzenli Olmayan Dillerin Yaklaşık Tanınması

  Tam olarak anlamadığım yaklaşık çarpma ve rasgele doğrulama üzerinde biraz çalışıyorlar.

• SE: İki çarpımı çarpmadan nasıl karşılaştırırım?
• Polinom zamanında istediğimiz kadar ön işlememize izin verildiğini varsayalım , doğrusal zamanda çözebilir miyiz ?$c$$ab=c$
• Doğrusal zamanlı belirsiz olmayan bir tamsayı çarpma algoritması var mı? Bkz. Http://compgroups.net/comp.theory/nondeterministic-linear-time-multiplication/1129399

  N-bit sayılarını O (n log (n) log (log (n))) karmaşıklığı gibi bir şeyle çarpmak için iyi bilinen algoritmalar vardır. Ve O (n) 'den daha iyisini yapamayız çünkü en azından tüm girdilere bakmalıyız. Benim sorum şu: "Belirsiz" algoritmaların uygun bir sınıfı için aslında O (n) 'ye ulaşabilir miyiz?

  Daha doğrusu, iki "a" ve "b" n-bit ikili sayısını ve 2-bit "c" sayısını kabul edebilen ve O (n) zamanında "a * b = c" olup olmadığını söyleyebilecek bir algoritma var mı? Değilse, bir algoritmanın ürünü doğrusal zamanda test etmek için kullanabileceği başka bir sertifika C (a, b, c) formu var mı? Doğrusal zaman değilse, ürünü test etme sorunu en azından asemptotik olarak hesaplamaktan daha kolay mıdır? Bu çizgiler boyunca bilinen herhangi bir sonuç memnuniyetle karşılanacaktır.

  John.

  -johnh4717

İşte ispatlamaya yönelik çok kısmi bir girişim . Biz sadece bizim decider içinde eklemeler ve subtractions bir (sabit sayı), hem de sabit bir sayı yararlanabilirler varsayalım numaraları önceden tanımlanmış wrt. Başka bir deyişle, karar vericimizde sabit sayıda , , vb. Yapabiliriz. Sonra hesaplayabildiğimiz tek miktarlar , 'nin önceden tanımlanmış sabitler olduğu . Not bu bir sürede elde edilebilir .${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|)$

Düzenlendi Bu karar, iff değerini belirlemek için kullanılır . puan olarak almayı düşünün . bitine , 4 boyutta bir hiperboloit olan yüzeyindeki konumu ile karar verilir . Giriş alanında bir nokta , yukarıdaki karartıcı bu giriş noktasının sınırlı mesafesindeki noktaları hesaplayabilir, yani bu noktalar vb. Bu, 4 uzayda bir küboid tanımlar.$B:B=1$$ad>bc$$a,b,c,d$$\mathbb{R}^4$$B$$ad = bc$$(a,b,c,d)$$q: |q-a| = k_1,$

(Bunu nasıl daha kesin hale getirebiliriz?) Küboid ile yüzeye olan mesafe genel olarak sınırsızdır ve bu nedenle yüzey kararlayıcı tarafından hesaplanamaz

İyi soru. Güven seviyesini kabul eder misiniz?

Belki de yaklaşık bölünme yapın. yani

A / b'nin sınırlayıcı yaklaşık bölümlerini hesaplamak için a'yı tavana (log_2 (b)) ve ayrıca zemine (log_2 (b)) doğru kaydırın. Sonra doğru bölümün bu iki değer arasında olduğunu biliyoruz.

Daha sonra, dört tamsayının göreceli boyutlarına bağlı olarak, belirli vakaları ekarte edebilir ve% 100 güven elde edebilir.

Prosedür 2 dışında bir sayı için tekrarlanabilir ve bu tür işlemler art arda bir şekilde bir işaret / kravat kopması değişikliği gözlenene kadar güven seviyesini artırabilir mi?

Bu benim ilk yöntem taslağım.

[cb] çarpmalarını önceden yapmak zorunda kalmadan reklam <cb'ye karar vermenin bir yolu var mı?

Elbette.

Fikir: Ondalık genişleme adım adım karşılaştırılır.

Tek kötü yanı, önce eşitliği dışlamak zorunda olduğumuzdur çünkü aksi takdirde feshedemeyebiliriz.
Öncelikle tamsayı parçalarını karşılaştırmak yararlıdır, çünkü bu kolaydır.

Bunu düşün:

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
}

do-whileSayılar eşit olmadığından döngünün sonlanması gerektiğini unutmayın . Ne kadar sürdüğünü bilmiyoruz; eğer sayılar çok yakınsa, biraz zaman alabilir.

Açıkçası pahalı bir çarpma yoktur; ihtiyacımız olan tek şey adayları ile çarpmak . Özellikle, ve açıkça hesaplamaktan kaçındık .$10$$ad$$cb$

Bu hızlı mı? Muhtemelen değil. Hesaplanacak çok sayıda tamsayı bölme, modlos ve gdcs vardır ve yineleme sayıları karşılaştırdığımız sayılar arasındaki mesafeyle ters orantılı olan bir döngüye sahibiz.

---

Yardımcı yöntem:

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