सच्ची यादृच्छिक बनाम छद्म-यादृच्छिक: वास्तव में क्या मायने रखता है

एक बटन दबाएँ, एक संख्या दिखती है, और मान लिया जाता है कि वह यादृच्छिक है। पूछने योग्य सवाल यह है कि उसे किसने उत्पन्न किया — क्योंकि दो उत्तरों में से एक सत्यापन योग्य है और दूसरा नहीं।

असली यादृच्छिकता कहाँ से आती है

सच्ची यादृच्छिकता उन भौतिक प्रक्रियाओं से आती है जो पिछली स्थिति से निर्धारित नहीं होतीं:

• रेडियोधर्मी क्षय — परमाणु के क्षय का सटीक क्षण अनुमानित नहीं किया जा सकता
• तापीय शोर — प्रतिरोधक में यादृच्छिक वोल्टेज उतार-चढ़ाव
• वायुमंडलीय शोर — बिजली की गतिविधि की पृष्ठभूमि स्थैतिक
• क्वांटम मापन — ऐसे परिणाम जो वास्तव में अनिश्चित हैं

ये यादृच्छिकता के अनुमान नहीं हैं। वे यादृच्छिक हैं, इस अर्थ में कि अतीत के बारे में कितना भी ज्ञान हो, परिणाम तय नहीं होता।

इसके बजाय कंप्यूटर क्या करता है

कंप्यूटर इनमें से किसी को भी सीधे नहीं देख सकता, इसलिए एक हार्डवेयर जनरेटर उनका नमूना लेता है। कच्चे बाइट्स /dev/urandom या समकक्ष ऑपरेटिंग सिस्टम स्रोत जैसी कहीं से आते हैं, जो स्वयं भौतिक प्रक्रियाओं से सीड होता है। वह सच्चा यादृच्छिक संख्या जनरेटर है।

बहुत अधिक सामान्य स्थिति है छद्म-यादृच्छिक संख्या जनरेटर: एक निर्धारक एल्गोरिदम जो ऐसा अनुक्रम बनाता है जो बस यादृच्छिक दिखता है।

next = (previous × multiplier + increment) mod modulus

महत्वपूर्ण गुण सूक्ष्म नहीं है। अगर आप एल्गोरिदम और सीड जानते हैं, तो आप उस अनुक्रम का हर वह मान निकाल सकते हैं जो वह कभी उत्पन्न करेगा। लगभग नहीं — बिल्कुल।

इसी कारण Math.random(), जिसे लगभग हर वेबसाइट उपयोग करती है, किसी भी महत्वपूर्ण काम के लिए अनुपयुक्त है। इसका आउटपुट आंतरिक स्थिति से तय होता है। देखे गए आउटपुट से उस स्थिति को निकालें और हर भविष्य का रोल अनुमानित हो जाता है।

सबसे अधिक उद्धृत उदाहरण यह है कि एक लीनियर कॉनग्रुएंशियल जनरेटर की पूरी स्थिति कुछ लगातार आउटपुट से निकाली जा सकती है। मर्सेन ट्विस्टर, जो Python में डिफ़ॉल्ट है, पुनर्निर्माण के लिए 624 आउटपुट माँगता है — और 624 वह संख्या है जहाँ आप सेकंडों में पहुँच जाते हैं।

Xorshift और इसी तरह के तेज़ जनरेटर में वही गुण अलग रूप में होता है: उत्कृष्ट सांख्यिकीय गुणवत्ता, पूरी तरह अनुमानित अगर आपके पास स्थिति हो।

वह मध्य मार्ग जो वास्तव में मायने रखता है

यह वह हिस्सा है जिसे अधिकांश व्याख्याएँ छोड़ देती हैं, और यही व्यवहार में उत्तर तय करता है।

आधुनिक वेब प्लेटफ़ॉर्म प्रति कॉल कच्चा /dev/urandom उपयोग नहीं करते। वे क्रिप्टोग्राफिक रूप से सुरक्षित PRNG उपयोग करते हैं — एक निर्धारक एल्गोरिदम, लेकिन हार्डवेयर एन्ट्रॉपी से सीड किया गया और ऐसे डिज़ाइन किया गया कि आउटपुट देखने से आप स्थिति पुनर्प्राप्त न कर सकें।

अंतर के बारे में सटीक होना उचित है, क्योंकि दोनों को अक्सर मिला दिया जाता है:

CSPRNG उसी अर्थ में निर्धारक है जिस अर्थ में आपके द्वारा उपयोग किया जाने वाला हर सॉफ़्टवेयर निर्धारक है। इसे स्वीकार्य बनाता है कि इसकी स्थिति उसके पहले जारी किए गए आउटपुट से पुनर्प्राप्त नहीं की जा सकती।

ब्राउज़र ठीक यही crypto.getRandomValues() के माध्यम से उजागर करते हैं। यह वही स्रोत है जिससे RandomSelect ड्रॉ करता है।

निष्पक्षता एक दूसरा सवाल है

अच्छे स्रोत के साथ भी समरूपता में गलती होना आसान है। एक d6 सीधा है: छह समान संभावित मान। एक d7 नहीं है, और “40 नामों में से 1 चुनें” भी नहीं।

सरल तरीका — 0 से 1 तक के यादृच्छिक फ्लोट को रेंज पर स्केल करना — निचले सिरे को पक्षपात देता है। 40 नामों के साथ, पहला अंतिम से थोड़ा अधिक बार आता, क्योंकि कुछ यादृच्छिक मान अंतिम बकेट के अंत से आगे गिरते हैं और असमान रूप से खारिज होते हैं।

सही तरीका है रिजेक्शन सैंपलिंग: ड्रॉ करें, और अगर परिणाम अपूर्ण अंतिम बकेट में गिरे, तो उसे खारिज करें और फिर ड्रॉ करें। वितरण बिल्कुल समरूप हो जाता है।

यह नज़रअंदाज़ करना आसान है क्योंकि पक्षपात छोटा है। व्यवहार में, कार्यान्वयन रेंज से बाहर के मानों को खारिज करके दोबारा ड्रॉ करता है, इसलिए हर प्रविष्टि की संभावना ठीक 1/N होती है — 40 नामों के ड्रॉ में भी, जहाँ स्केल-फ्लोट कार्यान्वयन पहले नाम को बहुत थोड़ी अधिक संभावना देता।

यही तकनीक शॉर्ट-ID जनरेटर में भी दिखती है, जहाँ कोड में टिप्पणी स्वीकृति दर और परिणामी पक्षपात लगभग दो भाग प्रति दस मिलियन बताती है। इतना छोटा कि अप्रासंगिक है, और इतना छोटा कि लापरवाह कार्यान्वयन बिना पहचाने रह जाता — और इसे मापने का उद्देश्य ठीक यही है।

व्यवहार में इसका क्या अर्थ है

दोपहर का भोजन चुनने के लिए, इनमें से कुछ भी मायने नहीं रखता। कोई भी जनरेटर स्वीकार्य भोजन बना देता है।

पुरस्कार ड्रॉ, कर्मचारी आवंटन, या प्रतिष्ठा से जुड़ी किसी भी चीज़ के लिए, सवाल यह है कि क्या आउटपुट का अनुमान पहले से लगाया जा सकता था। Math.random() के साथ सिद्धांत रूप में लगाया जा सकता था। crypto.getRandomValues() के साथ नहीं — यही अंतर है “हम कहते हैं यह यादृच्छिक था” और “तंत्र इसे ऐसा बनाता है” के बीच।

एनिमेशन के बारे में एक संबंधित और अक्सर भ्रमित करने वाला बिंदु है। घूमते पहिए पर, परिणाम पहिए के चलना शुरू करने से पहले तय हो जाता है; एनिमेशन उसी की ओर चलता है। कुछ पाठक इसे हेरफेर का प्रमाण मानते हैं। यह उल्टा है: चूँकि परिणाम पहले से तय है और समय से प्रभावित नहीं किया जा सकता, किसी के पास शोषण करने के लिए कोई इनपुट नहीं है। दृश्य उस मान के ऊपर एक तमाशा है जो पहले से तय है।

इसे स्वयं परखें

एक छोटा अभ्यास जिसके लिए कोई कोड नहीं चाहिए: एक पासा बीस बार फेंकें और परिणाम लिखें। फिर लगातार दोहराव खोजें।

आपको वे मिलेंगे। लगातार तीन छक्के लगभग हर पचास रोल में एक बार आते हैं। यह पासे के भारी होने का संकेत नहीं है — एक निष्पक्ष प्रक्रिया छोटे नमूने में ऐसी ही दिखती है।

फिर सौ बार फेंकें और हर फलक गिनें। अंतराल घटते हैं। कोई अभिसरित नहीं हो रहा, क्योंकि भरने के लिए कोई कमी थी ही नहीं: निकट से देखने पर स्वतंत्रता का यही अर्थ है।

और कहाँ पढ़ें

इस साइट का निष्पक्षता पृष्ठ वास्तविक कार्यान्वयन से गुज़रता है, जिसमें रिजेक्शन सैंपलिंग चरण भी शामिल है। इसे एक बार पढ़ना उचित है, विशेष रूप से अगर आप ऐसे निर्णय के लिए टूल चुन रहे हैं जिस पर सवाल उठेंगे।

व्यावहारिक सारांश संक्षिप्त है: जो टूल crypto.getRandomValues() उपयोग करता है और रेंज से बाहर के ड्रॉ खारिज करता है, वह सही काम कर रहा है, और आपको उसकी बात मानने की ज़रूरत नहीं — आप इसके बजाय तंत्र पर तर्क कर सकते हैं।