इस "भोली" एल्गोरिथ्म में क्या गलत है?

Question

यह बेतरतीब ढंग से एक सरणी फेरबदल के बारे में एक Stackoverflow सवाल के लिए अनुवर्ती है ।

वहाँ स्थापित एल्गोरिदम (जैसे कि नथ-फिशर-येट्स शफल ) हैं, जिसे किसी व्यक्ति को "भोले" तदर्थ कार्यान्वयन पर भरोसा करने के बजाय एक सरणी में फेरबदल करने के लिए उपयोग करना चाहिए।

मुझे अब यह साबित करने (या नापसंद) करने में दिलचस्पी है कि मेरा भोला-भाला एल्गोरिथ्म टूट गया है (जैसे: समान संभाव्यता वाले सभी संभावित क्रम उत्पन्न नहीं करता है)।

यहाँ एल्गोरिथ्म है:

दो बार लूप करें (सरणी की लंबाई करना चाहिए), और प्रत्येक पुनरावृत्ति में, दो यादृच्छिक सरणी अनुक्रमित करें और वहां दो तत्वों को स्वैप करें।

जाहिर है, यह KFY (दो बार जितना अधिक) की तुलना में अधिक यादृच्छिक संख्याओं की आवश्यकता है, लेकिन इससे अलग यह ठीक से काम करता है? और पुनरावृत्तियों की उपयुक्त संख्या क्या होगी ("सरणी की लंबाई" पर्याप्त है)?

Comments

मैं अभी यह नहीं समझ पा रहा हूं कि लोग क्यों सोचते हैं कि यह अदला-बदली वित्त वर्ष की तुलना में 'सरल' या 'अधिक भोली' है ... जब मैं पहली बार इस समस्या को हल कर रहा था तो मैंने केवल वित्तीय वर्ष लागू किया है (यह जानते हुए भी कि इसका कोई नाम नहीं है) , सिर्फ इसलिए कि यह मेरे लिए करने का सबसे सरल तरीका लग रहा था।

@mbq: व्यक्तिगत रूप से, मैं उन्हें समान रूप से आसान लगता हूं, हालांकि मैं मानता हूं कि FY मुझे अधिक "स्वाभाविक" लगता है।

— निको

जब मैंने अपने स्वयं के लेखन के बाद फेरबदल के एल्गोरिदम पर शोध किया (एक अभ्यास जिसे मैंने छोड़ दिया है), मैं सभी "पवित्र बकवास था, यह हो गया है, और इसका एक नाम है !!"

— जेएम

DataGenetics ब्लॉग में इस फेरबदल एल्गोरिथ्म के साथ क्या गलत है पर एक उत्कृष्ट सचित्र लेखन है ।

— DMGregory

Answer 1

यह टूट गया है, हालांकि यदि आप पर्याप्त फेरबदल करते हैं तो यह एक उत्कृष्ट सन्निकटन हो सकता है (जैसा कि पिछले उत्तरों ने संकेत दिया है)।

बस जो चल रहा है उस पर एक हैंडल पाने के लिए, विचार करें कि आपका एल्गोरिथ्म कितनी बार तत्व सरणी के फेरबदल उत्पन्न करेगा जिसमें पहला तत्व तय किया गया है, । जब क्रमपरिवर्तन समान संभावना के साथ उत्पन्न होते हैं, तो यह समय का होना चाहिए । अपने एल्गोरिथ्म के साथ फेरबदल के बाद को इस घटना की सापेक्ष आवृत्ति होने दें । आइए उदार बनें, और मान लें कि आप वास्तव में अपने फेरबदल के लिए यादृच्छिक रूप से समान रूप से अनुक्रमित जोड़े के अलग-अलग जोड़े का चयन कर रहे हैं , ताकि प्रत्येक जोड़ी को संभावना =कश्मीर ≥ 2 1 / कश्मीर पी एन एन 1 / ($k$$k \ge 2$$1/k$$p_n$$n$ 2/(के(k-1)$1/{k \choose 2}$$2/\left( k (k-1) \right)$। (इसका मतलब है कि कोई "तुच्छ" शफ़ल व्यर्थ नहीं हैं। दूसरी तरफ, यह दो-तत्व सरणी के लिए आपके एल्गोरिथ्म को पूरी तरह से तोड़ देता है, क्योंकि आप दो तत्वों को ठीक करने और उन्हें स्वैप करने के बीच वैकल्पिक करते हैं, इसलिए यदि आप एक पूर्व निर्धारित संख्या के बाद बंद कर देते हैं कदम, जो भी परिणाम के लिए कोई यादृच्छिकता है! "

यह आवृत्ति एक सरल पुनरावृत्ति को संतुष्ट करती है, क्योंकि पहला तत्व अपने मूल स्थान में फेरबदल के बाद दो निराशाजनक तरीकों से पाया जाता है। एक यह है कि यह फेरबदल के बाद तय किया गया था और अगला फेरबदल पहले तत्व को स्थानांतरित नहीं करता है। दूसरा यह है कि इसे फेरबदल के बाद स्थानांतरित किया गया था लेकिन फेरबदल इसे वापस ले जाता है। पहले तत्व को न ले जाने का मौका = बराबर होता है, जबकि पहला तत्व वापस जाने का मौका बराबर होता है = । जिस कारण से:एन एन एन + 1 रों टी ( कश्मीर - $n+1$$n$$n$$n+1^{st}$ (k-2)/k1/ (${k-1 \choose 2}/{k \choose 2}$$(k-2)/k$ 2/(के(k-1)$1/{k \choose 2}$$2/\left( k (k-1) \right)$

$$p_0 =1$$ क्योंकि पहला तत्व अपने सही स्थान पर शुरू होता है;

$$p_{n+1} = \frac{k-2}{k} p_n + \frac{2}{k(k-1)} \left( 1 - p_n \right).$$

उपाय है

$$p_n = 1/k + \left( \frac{k-3}{k-1} \right) ^n \frac{k-1}{k}.$$

घटाकर , हम देखते हैं कि आवृत्ति गलत है by । बड़े और , एक अच्छा सन्निकटन । यह दिखाता है कि इस विशेष आवृत्ति में त्रुटि सरणी ( ) के आकार के सापेक्ष स्वैप की संख्या के साथ तेजी से घट जाएगी , यह दर्शाता है कि यदि आप अपेक्षाकृत बड़ी संख्या में स्वैप कर चुके हैं, तो बड़े सरणियों के साथ पता लगाना मुश्किल होगा। -लेकिन त्रुटि हमेशा रहती है।( k - $1/k$ knk-$\left( \frac{k-3}{k-1} \right) ^n \frac{k-1}{k}$$k$$n$n/$\frac{k-1}{k} \exp(-\frac{2n}{k-1})$$n/k$

सभी आवृत्तियों में त्रुटियों का एक व्यापक विश्लेषण प्रदान करना मुश्किल है। यह संभावना है कि वे इस तरह का व्यवहार करेंगे, हालांकि, यह दर्शाता है कि न्यूनतम रूप से आपको त्रुटि को काफी छोटा करने के लिए (स्वैप की संख्या) की आवश्यकता होगी । एक अनुमानित समाधान है$n$

$$n \gt \frac{1}{2} \left(1 - (k-1) \log(\epsilon) \right)$$

जहाँ की तुलना में बहुत छोटा होना चाहिए । इसका तात्पर्य है कि क्रोड सन्निकटन के लिए को कई बार होना चाहिए ( यानी , जहाँ गुना या तो के क्रम पर है।)1 / k n k ϵ 0.01 1 /$\epsilon$$1/k$$n$$k$$\epsilon$$0.01$$1/k$

यह सब इस सवाल का जवाब देता है: आप एक एल्गोरिथ्म का उपयोग करना क्यों चुनेंगे जो काफी (लेकिन केवल लगभग) सही नहीं है, ठीक उसी तकनीक को दूसरे एल्गोरिथम के रूप में नियोजित करता है जो कि काफी हद तक सही है, और फिर भी जिसे अधिक गणना की आवश्यकता है?

संपादित करें

थिलो की टिप्पणी उपयुक्त है (और मैं उम्मीद कर रहा था कि कोई भी इसे इंगित नहीं करेगा, इसलिए मुझे इस अतिरिक्त काम को बख्शा जा सकता है)। मुझे तर्क समझाने दो।

• यदि आप हर बार वास्तविक स्वैप उत्पन्न करना सुनिश्चित करते हैं, तो आप पूरी तरह से खराब हैं। केस लिए मैंने जो समस्या बताई है, वह सभी सरणियों तक फैली हुई है। सभी संभावित अनुमतियों में से केवल आधे को स्वैप की एक समान संख्या को लागू करके प्राप्त किया जा सकता है; अन्य आधे भाग को विषम संख्या में स्वैप करके प्राप्त किया जाता है। इस प्रकार, इस स्थिति में, आप क्रमपरिवर्तन के एक समान वितरण के पास कभी भी कहीं भी उत्पन्न नहीं कर सकते हैं (लेकिन बहुत सारे संभव हैं कि किसी भी बड़े आकार के लिए सिमुलेशन अध्ययन समस्या का पता लगाने में असमर्थ होगा)। यह वास्तव में बुरा है।$k=2$$k$

• इसलिए यादृच्छिक पर दो पदों को स्वतंत्र रूप से उत्पन्न करके यादृच्छिक पर स्वैप उत्पन्न करना बुद्धिमानी है। इसका मतलब यह है कि प्रत्येक बार एक तत्व को स्वैप करने का मौका है; वह है, कुछ न करने का। यह प्रक्रिया प्रभावी रूप से एल्गोरिथ्म को थोड़ा धीमा कर देती है: चरणों के बाद , हम केवल सही स्वैप की उम्मीद करते हैं।n k - $1/k$$n$$\frac{k-1}{k} N \lt N$

• ध्यान दें कि त्रुटि का आकार अलग-अलग स्वैप की संख्या के साथ एकरस रूप से घटता है। इसलिए, औसत पर कम स्वैप का आयोजन भी त्रुटि को बढ़ाता है, औसतन। लेकिन यह एक ऐसी कीमत है जिसे आपको पहली गोली में वर्णित समस्या को दूर करने के लिए भुगतान करने के लिए तैयार होना चाहिए। नतीजतन, मेरा त्रुटि अनुमान रूढ़िवादी रूप से कम है, लगभग कारक से ।$(k-1)/k$

मैं एक दिलचस्प स्पष्ट अपवाद को भी इंगित करना चाहता था: त्रुटि सूत्र पर एक करीबी नज़र रखने से पता चलता है कि केस में कोई त्रुटि नहीं है । यह कोई गलती नहीं है: यह सही है। हालांकि, यहां मैंने क्रमपरिवर्तन के समान वितरण से संबंधित केवल एक आंकड़े की जांच की है। तथ्य यह है कि एल्गोरिथ्म (अर्थात्, किसी भी स्थिति को ठीक करने वाले क्रमपरिवर्तन की सही आवृत्ति प्राप्त करना) इस एक आंकड़े को पुन: उत्पन्न कर सकता है , यह गारंटी नहीं देता है कि क्रमपरिवर्तन वास्तव में समान रूप से वितरित किए गए हैं। वास्तव में, वास्तविक स्वैप के बाद , उत्पन्न होने वाले एकमात्र संभावित परमिट ,k = 3 2 n ( 123 ) ( 321 ) 2 n + 1 ( 12 ) ( 23 ) ( 13 $k=3$$k=3$$2n$$(123)$$(321)$, और पहचान। केवल उत्तरार्द्ध किसी भी दिए गए स्थान को ठीक करता है, इसलिए वास्तव में एक तिहाई क्रमपरिवर्तन एक स्थिति को ठीक करते हैं। लेकिन आधे परमिट गायब हैं! दूसरे मामले में, वास्तविक स्वैप के बाद, केवल संभावित क्रमपरिवर्तन , , और । फिर से, इनमें से कोई भी किसी भी स्थिति को ठीक कर देगा, इसलिए फिर से हम उस स्थिति को ठीक करने वाले क्रमपरिवर्तन की सही आवृत्ति प्राप्त करते हैं, लेकिन फिर से हम संभावित पारगमनों का केवल आधा हिस्सा प्राप्त करते हैं।$2n+1$$(12)$$(23)$$(13)$

यह छोटा उदाहरण तर्क के मुख्य किस्में को प्रकट करने में मदद करता है: "उदार" होने से हम एक विशेष रूप से सांख्यिकीय रूप से त्रुटि दर को कम आंकते हैं। क्योंकि वह त्रुटि दर सभी , हम देखते हैं कि एल्गोरिथ्म टूट गया है। इसके अलावा, इस आँकड़ों के लिए त्रुटि दर में क्षय का विश्लेषण करके हम एल्गोरिदम के पुनरावृत्तियों की संख्या पर एक कम बाध्य स्थापित करते हैं, जो क्रमपरिवर्तन के समान वितरण को अंजाम देने के लिए किसी भी उम्मीद की जरूरत है।$k \ge 4$

Comments

"आइए उदार बनें, और मान लीजिए कि आप वास्तव में अपने फेरबदल के लिए समान रूप से अलग-अलग अनुक्रमित जोड़े का चयन कर रहे हैं"। मुझे समझ नहीं आता कि यह धारणा क्यों बनाई जा सकती है, और यह कैसे उदार है। यह संभव क्रमपरिवर्तन को छोड़ने के लिए प्रतीत होता है, जिसके परिणामस्वरूप एक कम यादृच्छिक वितरण होता है।

— थिलो सेप

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

— whuber

इस समस्या का पूरी तरह से क्रमांकन समूह के केली ग्राफ पर मार्कोव श्रृंखला के रूप में विश्लेषण किया जा सकता है। K = 1 के लिए संख्यात्मक गणना 7 के माध्यम से (5040 मैट्रिक्स द्वारा एक 5040!) पुष्टि करते हैं कि आकार में सबसे बड़ा eigenvalues ​​(1 और -1 के बाद) बिल्कुल । इसका तात्पर्य यह है कि एक बार जब आप क्रमचय के चिह्न को बदलने की समस्या का सामना कर चुके होते हैं (-1 के स्वदेशी के अनुरूप), सभी संभाव्यता में त्रुटियां दर या और तेज। मुझे संदेह है कि यह सभी बड़े लिए जारी रहेगा । ( 1 - 2 / ( कश्मीर - 1 ) ) एन$(k-3)/(k-1) = 1 - 2/(k-1)$$(1 - 2/(k-1))^n$$k$

— whuber

आप से बेहतर कर सकते हैं क्योंकि संभावनाएं संयुग्मता वर्गों पर अपरिवर्तनीय हैं, और केवल विभाजन हैं इसलिए आप इसके बजाय मैट्रिक्स का विश्लेषण कर सकते हैं । 15 7 15 × $5040 \times 5040$$15$$7$$15 \times 15$

— डगलस ज़रे

Answer 2

मुझे लगता है कि आपका सरल एल्गोरिदम कार्डों को सही ढंग से फेरबदल करेगा क्योंकि संख्या फेरबदल से अनंत हो जाता है।

मान लीजिए कि आपके पास तीन कार्ड हैं: {A, B, C}। मान लें कि आपके कार्ड निम्नलिखित क्रम में शुरू होते हैं: ए, बी, सी। फिर एक फेरबदल के बाद आपके पास निम्नलिखित संयोजन हैं:

{A,B,C}, {A,B,C}, {A,B,C} #You get this if choose the same RN twice.
{A,C,B}, {A,C,B}
{C,B,A}, {C,B,A}
{B,A,C}, {B,A,C}

इसलिए, कार्ड ए की स्थिति {1,2,3} होने की संभावना {5/9, 2/9, 2/9} है।

यदि हम दूसरी बार कार्ड को फेरबदल करते हैं, तो:

Pr(A in position 1 after 2 shuffles) = 5/9*Pr(A in position 1 after 1 shuffle) 
                                     + 2/9*Pr(A in position 2 after 1 shuffle) 
                                     + 2/9*Pr(A in position 3 after 1 shuffle) 

यह 0.407 देता है।

इसी विचार का उपयोग करके, हम पुनरावृत्ति संबंध बना सकते हैं, अर्थात:

Pr(A in position 1 after n shuffles) = 5/9*Pr(A in position 1 after (n-1) shuffles) 
                                     + 2/9*Pr(A in position 2 after (n-1) shuffles) 
                                     + 2/9*Pr(A in position 3 after (n-1) shuffles).

आर में इसे कोड करना (नीचे कोड देखें), कार्ड ए की संभावना {1,2,3} के रूप में {0.33334, 0.33333, 0.33333} में दस फेरबदल के बाद होने की संभावना देता है।

आर कोड

## m is the probability matrix of card position
## Row is position
## Col is card A, B, C
m = matrix(0, nrow=3, ncol=3)
m[1,1] = 1; m[2,2] = 1; m[3,3] = 1

## Transition matrix
m_trans = matrix(2/9, nrow=3, ncol=3)
m_trans[1,1] = 5/9; m_trans[2,2] = 5/9; m_trans[3,3] = 5/9

for(i in 1:10){
  old_m = m
  m[1,1] = sum(m_trans[,1]*old_m[,1])
  m[2,1] = sum(m_trans[,2]*old_m[,1])
  m[3,1] = sum(m_trans[,3]*old_m[,1])

  m[1,2] = sum(m_trans[,1]*old_m[,2])
  m[2,2] = sum(m_trans[,2]*old_m[,2])
  m[3,2] = sum(m_trans[,3]*old_m[,2])

  m[1,3] = sum(m_trans[,1]*old_m[,3])
  m[2,3] = sum(m_trans[,2]*old_m[,3])
  m[3,3] = sum(m_trans[,3]*old_m[,3])
}  
m

Comments

+1। यह दर्शाता है कि किसी दिए गए पद के लिए कार्ड की संभावना किसी दिए गए स्थान पर समाप्त होने की उम्मीद है, क्योंकि अनुपात में फेरबदल की संख्या बढ़ जाती है। हालाँकि, यह भी एक एल्गोरिथ्म के बारे में सच होगा जो सिर्फ यादृच्छिक राशि द्वारा एक बार सरणी को घुमाता है: सभी कार्डों की सभी पदों पर समाप्त होने की समान संभावना है, लेकिन अभी भी कोई यादृच्छिकता नहीं है (सरणी क्रमबद्ध बनी हुई है)।

— थिलो

@ थिलो: क्षमा करें, मैं आपकी टिप्पणी का अनुसरण नहीं करता। एक "एल्गोरिथ्म एक यादृच्छिक राशि से घूमता है" लेकिन अभी भी "कोई यादृच्छिकता" नहीं है? क्या आप आगे बता सकते हैं?

— csgillespie

यदि आप 0 और N-1 पदों (बेतरतीब ढंग से) के बीच इसे घुमाकर एन-एलिमेंट एरे को "फेरबदल" करते हैं, तो हर कार्ड में N के किसी भी पद के समाप्त होने की संभावना समान है, लेकिन 2 अभी भी 1 के बीच स्थित है और 3.

— थिलो

@ थियो: आह, मैं तुम्हारी बात समझ गया। वैसे आप प्रायोरिटी (ऊपर के समान विचार का उपयोग करके), Pr (A स्थिति 2 में) और Pr (A स्थिति 3 में) के लिए काम कर सकते हैं - कार्ड B और C. के लिए dito। आप देखेंगे कि सभी संभावनाएँ हैं 1/3। नोट: मेरा उत्तर केवल एक विशेष मामला देता है, जबकि @ अच्छा उत्तर सामान्य केस देता है।

— csgillespie

Answer 3

यह देखने का एक तरीका है कि आपको पूरी तरह से समान वितरण नहीं मिलेगा। समान वितरण में, प्रत्येक क्रमपरिवर्तन की संभावना। जब आप रैंडम ट्रांसपोज़िशन का एक क्रम उत्पन्न करते हैं , और फिर उनके उत्पाद द्वारा अनुक्रम एकत्र करते हैं, तो आपको प्राप्त होने वाली संभावनाएं कुछ पूर्णांक के लिए फॉर्म के रूप में होती हैं । यदि , फिर । बर्ट्रेंड के पोस्टुलेट (एक प्रमेय) के अनुसार, ऐसे अपराध हैं जो हर में होते हैं और जो विभाजित नहीं करते हैं , इसलिएएक पूर्णांक नहीं है, और में समान रूप से ट्रांज़िशन को विभाजित करने का एक तरीका नहीं हैt A / n 2 t A 1 / n ! = ए / एन 2 टी एन 2 टी / एन ! = एक n ≥ 3 एन एन 2 टी / n ! n ! n = 52 1 / 52 ! 3 , 5 , 7 , । । । , 47 1 $1/n!$$t$$A/n^{2t}$$A$$1/n! = A/n^{2t}$$n^{2t}/n! = A$$n \ge 3$$n$$n^{2t}/n!$$n!$क्रमपरिवर्तन। उदाहरण के लिए, यदि , तो का से विभाज्य है जबकि का भाजक नहीं है, इसलिए कम नहीं हो सकता है।$n=52$$1/52!$$3, 5, 7, ..., 47$$1/52^{2t}$$A/52^{2t}$$1/52!$

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

डायकोनिस, पी।, शाहशाहनी, एम। (1981): "यादृच्छिक रैंडमिशन के साथ यादृच्छिक क्रम उत्पन्न करना।" जेड। वॉर्श। Verw। Geb. 57, 159–179।

एक निष्कर्ष यह था कि इस अर्थ में transpositions लेता है कि क्रमपरिवर्तन यादृच्छिक से दूर हैं, लेकिन परिणाम कुल भिन्नता और दूरी के अर्थ में, यादृच्छिक के करीब है । इस प्रकार की कटऑफ घटना समूहों पर यादृच्छिक चालों में आम है, और प्रसिद्ध परिणाम से संबंधित है कि एक डेक यादृच्छिक के करीब होने से पहले आपको राइफल फेरबदल की आवश्यकता होती है ।$\frac 12 n \log n$$(1-\epsilon) \frac12 n \log n$$(1+\epsilon) \frac 12 n \log n$$L^2$$7$

Answer 4

इस बात को ध्यान में रखते हुए कि मैं एक सांख्यिकीविद् नहीं हूं, लेकिन मैं अपनी 2 सेंट लगाऊंगा।

मैंने आर में थोड़ा परीक्षण किया (सावधान, यह उच्च के लिए बहुत धीमा है numTrials, कोड शायद अनुकूलित किया जा सकता है):

numElements <- 1000
numTrials <- 5000

swapVec <- function()
    {
    vec.swp <- vec

    for (i in 1:numElements)
        {
        i <- sample(1:numElements)
        j <- sample(1:numElements)

        tmp <- vec.swp[i]
        vec.swp[i] <- vec.swp[j]
        vec.swp[j] <- tmp
        }

    return (vec.swp)
    }

# Create a normally distributed array of numElements length
vec <- rnorm(numElements)

# Do several "swapping trials" so we can make some stats on them
swaps <- vec
prog <- txtProgressBar(0, numTrials, style=3)

for (t in 1:numTrials)
    {
    swaps <- rbind(swaps, swapVec())
    setTxtProgressBar(prog, t)
    }

यह पंक्तियों (एक प्रति परीक्षण + मूल) और कॉलम (प्रत्येक वेक्टर तत्व में से एक ) के swapsसाथ एक मैट्रिक्स उत्पन्न करेगा । यदि विधि प्रत्येक कॉलम का वितरण सही है (ट्रायल पर प्रत्येक तत्व के लिए मानों का) मूल डेटा के वितरण से अलग नहीं होना चाहिए।numTrials+1numElements

क्योंकि हमारा मूल डेटा सामान्य रूप से वितरित किया गया था, हम उम्मीद करेंगे कि सभी कॉलम उस से विचलित न हों।

अगर हम दौड़ते हैं

par(mfrow= c(2,2))
# Our original data
hist(swaps[1,], 100, col="black", freq=FALSE, main="Original")
# Three "randomly" chosen columns
hist(swaps[,1], 100, col="black", freq=FALSE, main="Trial # 1") 
hist(swaps[,257], 100, col="black", freq=FALSE, main="Trial # 257")
hist(swaps[,844], 100, col="black", freq=FALSE, main="Trial # 844")

हमें मिला:

जो बहुत ही आशाजनक लग रहा है। अब, यदि हम सांख्यिकीय रूप से पुष्टि करना चाहते हैं कि वितरण मूल से विचलित नहीं होता है, तो मुझे लगता है कि हम कोलमोगोरोव-स्मिरनोव परीक्षण का उपयोग कर सकते हैं (कृपया कुछ सांख्यिकीविद् पुष्टि कर सकते हैं कि यह सही है?) और उदाहरण के लिए, क्या करें?

ks.test(swaps[1, ], swaps[, 234])

जो हमें p = 0.9926 देता है

यदि हम सभी कॉलमों की जाँच करते हैं:

ks.results <- apply(swaps, 2, function(col){ks.test(swaps[1,], col)})
p.values <- unlist(lapply(ks.results, function(x){x$p.value})

और हम दौड़ते हैं

hist(p.values, 100, col="black")

हमें मिला:

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

1> quantile(p.values)
       0%       25%       50%       75%      100% 
0.6819832 0.9963731 0.9999188 0.9999996 1.0000000

ध्यान दें, स्पष्ट रूप से, परीक्षणों की कम संख्या के साथ स्थिति उतनी अच्छी नहीं है:

50 परीक्षण

1> quantile(p.values)
          0%          25%          50%          75%         100% 
0.0003399635 0.2920976389 0.5583204486 0.8103852744 0.9999165730

100 ट्रायल हुए

          0%         25%         50%         75%        100% 
 0.001434198 0.327553996 0.596603804 0.828037097 0.999999591 

500 ट्रायल हुए

         0%         25%         50%         75%        100% 
0.007834701 0.504698404 0.764231550 0.934223503 0.999995887 

Answer 5

यहाँ मैं छद्म कोड में आपके एल्गोरिथ्म की व्याख्या कर रहा हूँ:

void shuffle(array, length, num_passes)
  for (pass = 0; pass < num_passes; ++pass) 
    for (n = 0; n < length; ++)
      i = random_in(0, length-1)
      j = random_in(0, lenght-1)
      swap(array[i], array[j]

$2 \times length \times num\_passes$$[0, length-1]$$length$

$length ^ {2 \times length \times num\_passes}$

$length !$$length ! < length ^ {2 \times length \times num\_passes}$

$length ! \bigm| length ^ {2 \times length \times num\_passes}$

$p$$p < length$$p \nmid length$$length > 2$$p \bigm| length!$$length ^ {2 \times length \times num\_passes}$$length ! \nmid length ^ {2 \times length \times num\_passes}$$length > 2$

$length$$p < length$$length-1$$length-1$$length$

$length$$length-1$$length !$$length! \bigm| length!$। यह दिखाना मुश्किल नहीं है कि प्रत्येक ट्रेस एक अलग क्रमचय में परिणाम करता है, और वहां से यह देखना आसान है कि फिशर-येट्स समान क्रमिकता के साथ प्रत्येक क्रमचय उत्पन्न करता है।