यह कैसे जांचें कि एक संख्या बहुपद समय में एक आदर्श शक्ति है या नहीं

23

AKS primality परीक्षण एल्गोरिथ्म का पहला चरण यह जांचना है कि इनपुट नंबर एक सही शक्ति है या नहीं। ऐसा लगता है कि यह संख्या सिद्धांत में एक प्रसिद्ध तथ्य है क्योंकि कागज ने इसे विवरण में नहीं समझाया था। क्या कोई मुझे बता सकता है कि बहुपद समय में ऐसा कैसे करें? धन्यवाद।

ds.algorithms nt.number-theory

— yzll
स्रोत

7

एकेएस एल्गोरिथ्म का पहला चरण यह परीक्षण करना है कि क्या इनपुट नंबर एक पूर्ण शक्ति है ( कुछ पूर्णांक c, n> 1 के लिए प्रपत्र की संख्या ), जो कि परीक्षण से भिन्न है कि क्या संख्या एक प्रमुख शक्ति है। एक संपूर्ण शक्ति के लिए परीक्षण कागज में उद्धृत पुस्तक का 9.44 व्यायाम है ( वॉन ज़्यूर गैथेन और गेरहार्ड, 2003 द्वारा आधुनिक कंप्यूटर बीजगणित )। मैंने पुस्तक नहीं पढ़ी है और मुझे इसका उत्तर नहीं पता है, लेकिन आपने पुस्तक की सलाह ली है?

c^{n}

$c^n$

— त्सुकोशी इतो

1

मेरा मानना है कि AKS जाँच का पहला चरण है यदि संख्या कुछ धनात्मक पूर्णांक की शक्ति है, जरूरी नहीं कि प्रधान हो। यदि यह ज्ञात था कि AKS से पहले बहुपद समय में एक प्रमुख शक्ति की जांच कैसे की जाती है, तो यह पहले से ही बहुपद समय प्रायोगिक परीक्षक देगा।

— अर्नब

@ त्सुयोशी मेरी गलती की ओर इशारा करने के लिए धन्यवाद। मैंने किताब की सलाह नहीं ली है।

— yzll

2

यदि आप प्रश्न के बारे में परवाह करते हैं , तो कृपया पोस्ट करने से पहले समस्या को हल करने का प्रयास करें।

— त्सुयोशी इतो

Tsuyoshi / arnab, शायद आपको जवाब के रूप में पुनर्निवेश करना चाहिए ताकि यह स्वीकार किया जा सके?

— सुरेश वेंकट

31

एक संख्या n को देखते हुए, यदि यह (b> 1) के रूप में लिखा जा सकता है , तो । और हर तय के लिए , जाँच यदि कोई मौजूद है साथ द्विआधारी खोज का उपयोग किया जा सकता है। कुल समय चल रहा है इसलिए मुझे लगता है। $a^b$ $b < \log(n) + 1$ $b$ $a$ $a^b = n$ $O(\log^2 n)$

— रामप्रसाद
स्रोत

5

रामप्रसाद का उत्तर प्रतिपादक करने का समय छोड़ देता है जो । दूसरा तरीका यह है कि का चयन करें और फिर की वीं जड़ की गणना करें, जिसमें का कुल समय होगा ।

O (l o g^{3} n)

$O(log^3 n)$

b

$b$

b

$b$

n

$n$

O (l o g^{3} n)

$O(log^3 n)$

— डेविड मारकिस

1

एक साधारण सुधार जो आगे चलकर केवल प्रधानमंत्री द्वारा एक कारक निकालता है ।

\log \log n

$\log \log n$

b

$b$

— जू में चाओ जू

16

बाख और सोरेनसन, छलनी एल्गोरिदम को सही शक्ति परीक्षण के लिए देखें, अल्गोरिथमिका 9 (1993), 313-328, डीओआई: 10.1007 / BF01228507, और डीजे बर्नस्टीन, अनिवार्य रूप से सही समय पर सही शक्तियों का पता लगाते हुए, मैथ। अनि। 67 (1998), 1253-1283।

— जेफरी शालिट
स्रोत

डीजे-बर्नस्टीन, एच। वी। लेनस्ट्रा जूनियर और जे। पिला, कोप्रेम, मैथ में फैक्टरिंग करके सही शक्तियों का पता लगाते हुए, बेहतर एस्पिरोटिक रनिंग टाइम और सरल उपचार के साथ एक फॉलो-अप पेपर भी है। अनि। 76 (2007), 385388।

— एरिक वोंग

3

मुझे कागज में एक दिलचस्प और सुरुचिपूर्ण समाधान मिला: ए.के.एस. क्लास प्राइमलिटी टेस्ट के कार्यान्वयन पर, आर। क्रैंडाल और जे.पापदोपोलोस द्वारा, 18 मार्च 2003।

— Plomb
स्रोत

2

किसी तरह, मैं दिखा सकता हूं कि द्विआधारी खोज एल्गोरिथ्म । $O(lg~n \cdot (lg~lg~n)^2)$

सबसे पहले, , वहाँ । बाइनरी सर्च एल्गोरिथ्म: प्रत्येक , हम खोजने के लिए बाइनरी खोज का उपयोग करते हैं । $a^b = n$ $b<lg~n$
$b$ $a$

हर बार तेज घातांक का उपयोग करके लागत संचालन की गणना । इसलिए, शेष अंक की श्रेणी । $a^b$ $lg~b = lg~lg~n$ $a$

यदि का अधिकतम संभव मान , तो बाइनरी खोज को संचालन की आवश्यकता है $A$ $a$ $lg~A$

ध्यान दें कि , यह जब , $b~lg~a = lg~n$

l g A = \frac{l g n}{b}

$lg~A = \frac{lg~n}{b}$

\sum l g A = l g n \cdot (\frac{1}{1} + \frac{1}{2} + . . . + \frac{1}{B}) = l g n \cdot l g B = l g n \cdot l g l g n

$\sum lg~A = lg~n \cdot (\frac{1}{1} + \frac{1}{2} + ... + \frac{1}{B}) = lg~n \cdot lg~B = lg~n \cdot lg~lg~n$

दूसरे शब्दों में, द्विआधारी खोज के सभी ऑपरेशन $O(lg~n \cdot lg~lg~n)$

के संचालन पर विचार करें , यह अंत में है। $a^b$ $O(lg~n \cdot (lg~lg~n)^2)$

ps: सभी lg बेस 2 हैं।

पायथन कोड:

#--- a^n ---------------------------------------
def fast_exponentation(a, n):
    ans = 1
    while n:
        if n & 1 : ans = ans * a
        a = a * a
        n >>= 1
    return ans
#------------------------------------------
# Determines whether n is a power a ^ b, O(lg n (lg lg n) ^ 2)
def is_power(n):
    if (- n & n) == n: return True  # 2 ^ k
    lgn = 1 + ( len( bin ( abs ( n ) ) ) - 2)
    for b in range(2,lgn):
        # b lg a = lg n
        lowa = 1L
        higha = 1L << (lgn / b + 1)
        while lowa < higha - 1:
            mida = (lowa + higha) >> 1
            ab = fast_exponentation(mida,b) 
            if ab > n:   higha = mida
            elif ab < n: lowa  = mida
            else:   return True # mida ^ b
    return False

— केविन
स्रोत