अतिप्रवाह त्रुटियों के बिना कंप्यूटर घातीय गणित की गणना कैसे कर सकते हैं?

Question

कुछ आरएसए एन्क्रिप्ट / डिक्रिप्ट विधियों का अध्ययन करते हुए, मुझे यह लेख मिला: आरएसए एल्गोरिथम का एक उदाहरण

इसे इस संदेश को डिक्रिप्ट करने की आवश्यकता है

कुल परिणाम इतना बड़ा है, 64-बिट / 32-बिट मशीन के लिए, मुझे विश्वास नहीं है कि यह एक रजिस्टर में इतना बड़ा मूल्य रख सकता है। ओवरफ्लो के बिना कंप्यूटर इसे कैसे करता है?

---

यह प्रश्न सप्ताह का एक सुपर यूजर प्रश्न था । अधिक जानकारी के लिए ब्लॉग प्रविष्टि
पढ़ें या स्वयं ब्लॉग में योगदान करें

Comments

मुझे आश्चर्य है कि अगर आपको यह cs.stackexchange.com पर माइग्रेट हो गया तो बेहतर जवाब मिलेगा। ऐसा लगता है कि यह एक सीएस / गणित साइट पर बेहतर फिट हो सकता है जो कम चीजों के वास्तविक विवरणों पर बहुत अधिक ध्यान केंद्रित करते हैं जो वास्तव में उच्च स्तर पर नीचे हैं।

— ०२ पर Zoredache

यह सुपर यूजर के लिए पर्याप्त है।

— जेम्स मर्ट्ज़

Answer 1

क्योंकि पूर्णांक मापांक ऑपरेशन एक रिंग होमोमोर्फिज्म ( विकिपीडिया )> -> ℤ / nℤ, से है

(X * Y) mod N = (X mod N) * (Y mod N) mod N

आप इसे थोड़ा सरल बीजगणित के साथ स्वयं सत्यापित कर सकते हैं। (ध्यान दें कि modदाएं हाथ की तरफ अंतिम एक मॉड्यूलर रिंग में गुणा की परिभाषा के कारण दिखाई देता है।)

कंप्यूटर बड़ी संख्या में अंकों की गणना किए बिना मॉड्यूलर रिंगों में घातांक की गणना करने के लिए इस ट्रिक का उपयोग करते हैं।

               / 1 I = 0,
               |
(X ^ I) mod N = <(X * (X ^ (I-1) mod N)) mod NI विषम,
               |
               \ (X ^ (I / 2) mod N) ^ 2 मॉड NI यहां तक ​​कि I / = 0।

एल्गोरिथम रूप में,

-- compute X^I mod N
function expmod(X, I, N)
    if I is zero
        return 1
    elif I is odd
        return (expmod(X, I-1, N) * X) mod N
    else
        Y <- expmod(X, I/2, N)
        return (Y*Y) mod N
    end if
end function

आप इसे (855^2753) mod 3233केवल 16-बिट रजिस्टरों के साथ गणना करने के लिए उपयोग कर सकते हैं , यदि आप चाहें।

हालांकि, आरएसए में एक्स और एन के मूल्य बहुत बड़े हैं, एक रजिस्टर में फिट होने के लिए बहुत बड़े हैं। एक मापांक आमतौर पर 1024-4096 बिट्स लंबा होता है! तो आप कंप्यूटर को "लंबे" तरीके से गुणा कर सकते हैं, उसी तरह हम हाथ से गुणा करते हैं। केवल अंक 0-9 का उपयोग करने के बजाय, कंप्यूटर "शब्द" 0-2 ¹⁶ -1 या ऐसा कुछ उपयोग करेगा । (केवल 16 बिट्स का उपयोग करने का मतलब है कि हम दो 16 बिट संख्याओं को गुणा कर सकते हैं और विधानसभा भाषा का सहारा लिए बिना पूर्ण 32 बिट परिणाम प्राप्त कर सकते हैं। असेंबली भाषा में, पूर्ण रूप से 64 बिट परिणाम प्राप्त करना बहुत आसान है, या 64-बिट कंप्यूटर के लिए पूर्ण 128-बिट परिणाम।)

-- Multiply two bigints by each other
function mul(uint16 X[N], uint16 Y[N]):
    Z <- new array uint16[N*2]
    for I in 1..N
        -- C is the "carry"
        C <- 0
        -- Add Y[1..N] * X[I] to Z
        for J in 1..N
            T <- X[I] * Y[J] + C + Z[I + J - 1]
            Z[I + J - 1] <- T & 0xffff
            C <- T >> 16
        end
        -- Keep adding the "carry"
        for J in (I+N)..(N*2)
            T <- C + Z[J]
            Z[J] <- T & 0xffff
            C <- T >> 16
        end
    end
    return Z
end
-- footnote: I wrote this off the top of my head
-- so, who knows what kind of errors it might have

यह X द्वारा Y को समय की मात्रा में लगभग गुणा करेगा, X में शब्दों की संख्या के बराबर लगभग Y में शब्दों की संख्या से गुणा करता है। इसे O (N ² ) समय कहा जाता है । यदि आप ऊपर दिए गए एल्गोरिथ्म को देखते हैं और उसे अलग करते हैं, तो यह वही "लंबी गुणा" है जो वे स्कूल में पढ़ाते हैं। यदि आपके पास 10 अंकों के लिए समय सारणी नहीं है, लेकिन यदि आप बैठते हैं और इसे काम करते हैं, तब भी आप 1,926,348 x 8,192,004 गुणा कर सकते हैं।

लंबी गुणा:

    1,234
  x 5,678
---------
    9,872
   86,38
  740,4
6,170
---------
7,006,652

वास्तव में गुणा ( विकिपीडिया ) के लिए आसपास कुछ तेज एल्गोरिदम हैं , जैसे स्ट्रैसेन की फास्ट फूरियर विधि, और कुछ सरल तरीके जो अतिरिक्त जोड़ और घटाव लेकिन कम गुणा करते हैं, और इसलिए तेजी से समग्र रूप से समाप्त होते हैं। GMP जैसी संख्यात्मक लाइब्रेरी विभिन्न संख्याओं के आधार पर विभिन्न एल्गोरिदम का चयन करने में सक्षम हैं: संख्याओं के लिए फूरियर रूपांतरण केवल सबसे तेज़ है, छोटी संख्या सरल एल्गोरिदम का उपयोग करती है।

Comments

+1, लेकिन आप mod Nचीनी अवशेष प्रमेय के अंत में एक अतिरिक्त याद कर रहे हैं । ( (16 mod 5)इसके बराबर नहीं है (4 mod 5) * (4 mod 5): पूर्व 1 है, बाद वाला 16 है।)

— बरखा

@ruakh: सही किया गया। हालाँकि मैं वास्तव में कहना चाहता हूँ, R / kR is isomorphic to R / k1R x R / k2R x ... R / knR, जहाँ k1..kn युग्मक सहसंबंध हैं, उनका उत्पाद k है, और R एक प्रमुख आदर्श डोमेन है। मैं इतने लंबे समय से * ओवरलोडिंग कर रहा हूं कि इसे कुछ भी लेकिन मॉड्यूलर के रूप में देखना मुश्किल है । दूसरे शब्दों में, मेरे सामान्य रूप से उल्लेखनीय सम्मेलनों के तहत बहुत ही कम modहै।

— डिट्रिच एप ईपल

@ सिंथेटेक: लेकिन मुझे उन चार शब्दों से बहुत प्यार है: "पाठक के लिए व्यायाम।"

— डिट्रिच एप ईपल

(X * Y) mod N = (X mod N) * (Y mod N) mod Nसच है, लेकिन इसका चीनी अवशेष प्रमेय से कोई लेना-देना नहीं है।

— डेनिस

@ डेनिस: मैंने अब जवाब में कोडोमैन की संरचना को स्पष्ट किया है। (यह मेरे लिए कभी भी अस्पष्ट नहीं है, क्योंकि मैंने इसे लिखा है ...)

— डिट्रिच एप्प जूल

Answer 2

बस जवाब है कि वे अपने दम पर नहीं कर सकते। वास्तव में, यदि आप एक एक्स-बिट मशीन की अवधारणा लेते हैं, तो सीमित संख्या में बिट्स को सीमित संख्याओं द्वारा दर्शाया जा सकता है, ठीक उसी तरह सीमित संख्या में नंबर होते हैं जिन्हें 2 अंकों द्वारा दर्शाया जा सकता है। दशमलव प्रणाली।

कहा जा रहा है कि बहुत बड़ी संख्या में कंप्यूटर का प्रतिनिधित्व क्रिप्टोग्राफी के क्षेत्र का एक बड़ा घटक है। कंप्यूटर में बहुत बड़ी संख्याओं का प्रतिनिधित्व करने के कई तरीके हैं, प्रत्येक अगले के रूप में विविध हैं।

इन विधियों में से प्रत्येक के अलग-अलग फायदे और नुकसान हैं, और जब तक मैं सभी तरीकों को यहाँ सूचीबद्ध नहीं करता / नहीं करता, मैं एक बहुत ही सरलता से प्रस्तुत करूंगा।

मान लीजिए कि एक पूर्णांक केवल 0-99 से मान रख सकता है। कोई 100 नंबर का प्रतिनिधित्व कैसे कर सकता है? यह पहली बार में असंभव लग सकता है, लेकिन ऐसा इसलिए है क्योंकि हम केवल एक ही चर पर विचार करते हैं। अगर मुझे एक पूर्णांक कहा जाता है unitsऔर एक को बुलाया जाता है hundreds, तो मैं आसानी से 100 का प्रतिनिधित्व कर सकता हूं hundreds = 1; units = 0;:। मैं आसानी से एक बड़ी संख्या का प्रतिनिधित्व कर सकता था, जैसे 9223 hundreds = 92; units = 23:।

हालांकि यह एक आसान तरीका है, कोई यह तर्क दे सकता है कि यह बहुत अक्षम है। अधिकांश एल्गोरिदम की तरह जो एक कंप्यूटर क्या कर सकता है की सीमाओं को धक्का देता है, यह आमतौर पर शक्ति (बड़ी संख्या का प्रतिनिधित्व) और दक्षता (तेजी से पुनर्प्राप्ति / भंडारण) के बीच एक टग-ओ-युद्ध है। जैसा कि मैंने पहले कहा था, कंप्यूटर में बड़ी संख्या का प्रतिनिधित्व करने के कई तरीके हैं; बस एक विधि और इसके साथ प्रयोग करें!

मुझे उम्मीद है इसने आपके सवाल का जवाब दे दिया है!

आगे की पढाई:यह लेख और यह अधिक जानकारी के लिए काम आ सकता है।

Answer 3

जिस तरह से यह किया जा सकता है (दोहराए गए स्क्वरिंग और इस तरह से शामिल होने के बहुत तेज़ तरीके हैं) गुणा करके है, और प्रत्येक गुणा के बाद मापांक लेते हैं। जब तक मापांक वर्ग 2 ^ 32 (या 2 ^ 64) से कम है, तब तक यह अतिप्रवाह नहीं होगा।

Answer 4

उसी तरह से आप कर सकते हैं।

मैं अनुमान लगाने जा रहा हूं कि आप यह नहीं जानते कि 342 * 189 क्या है। लेकिन आप निम्नलिखित तथ्यों को जानते हैं:

9 * 2 = 18
9 * 4 = 36
9 * 3 = 27
8 * 2 = 16
8 * 4 = 32
8 * 3 = 24
1 * 2 = 2
1 * 4 = 4
1 * 3 = 3

18 + 360 + 2700 + 160 + 3200 + 24000 + 200 + 4000 + 30000 = 64638

इन सरल तथ्यों को जानकर, और उन्हें हेरफेर करने के लिए एक तकनीक सीखी, आप अंकगणित कर सकते हैं जो आप अन्यथा नहीं कर सकते।

एक ही टोकन के द्वारा, एक कंप्यूटर जो एक बार में 64 बिट्स से अधिक गणित को नहीं संभाल सकता है, बड़ी समस्याओं को आसानी से छोटे टुकड़ों में तोड़ सकता है, उन छोटे टुकड़ों को कर सकता है, और बड़े, उत्तर के उत्तर बनाने के लिए उन्हें वापस एक साथ रख सकता है। अचूक समस्या।

Answer 5

जहां तक ​​इसके अलावा और घटाव का संबंध है, कई सीपीयू में "कैरी बिट" होता है जो कि सेट होता है अगर अंकगणितीय ऑपरेशन बह निकला हो। इसलिए यदि परिणाम के लिए स्टोर करने के लिए 8 बाइट्स की आवश्यकता होगी, और सीपीयू 32-बिट्स (जो equls 4 8-बिट बाइट्स है), यह दो अतिरिक्त संचालन कर सकता है, पहले "कम शब्द" पर और फिर "उच्च शब्द" पर ओवरफ्लो के साथ कैरी बिट का ख्याल रखना। पहले कैरी को साफ करना आवश्यक है। यह एक कारण है कि उच्च बिट सीपीयू प्रदर्शन बढ़ाते हैं क्योंकि यह उतना नहीं करना पड़ता है।

बेशक यह 8-बिट सीपीयू के साथ मेरे सीमित असेंबलर अनुभव से है। मुझे नहीं पता कि कैरी बिट आधुनिक सीपीयू के साथ गुणा और निर्देश के साथ कैसे काम करता है। गैर-इंटेल आरआईएससी सीपीयू भी अलग तरह से व्यवहार कर सकते हैं।

मैं फ़्लोटिंग पॉइंट गणित के बारे में बहुत अधिक नहीं जानता, लेकिन मूल रूप से बाइट्स निश्चित स्थानों का प्रतिनिधित्व करते हैं, लेकिन विशिष्ट स्थान नहीं। इसलिए इसे "फ्लोटिंग" बिंदु कहा जाता है। इसलिए, उदाहरण के लिए, संख्या 34459234 3.4459234, या 3.4459234E + 20 (जो कि 3.4459234 x 10 ^ 20) के रूप में लगभग उसी मेमोरी स्पेस का उपभोग करेगी।