ความสัมพันธ์ระหว่างไพ่สองสำรับ?

ฉันได้เขียนโปรแกรมเพื่อจำลองการสลับไพ่ ฟาด

ไพ่แต่ละใบมีหมายเลขโดยมีชุดสูทจากCLUBS, DIAMONDS, HEARTS, SPADESและอันดับจากสองถึงสิบจากนั้นแจ็ค, Queen, King และ Ace ดังนั้น Two of Clubs จึงมีหมายเลข 1, Three of Clubs a 2 .... Ace of Clubs คือ 13 ... Ace of Spades คือ 52

หนึ่งในวิธีการในการกำหนดวิธีสับไพ่คือการเปรียบเทียบกับไพ่ที่ไม่ได้สับไพ่และดูว่าลำดับของไพ่มีความสัมพันธ์กันหรือไม่

นั่นคือฉันอาจมีการ์ดเหล่านี้พร้อมกับการ์ดที่ไม่มีการสับเพื่อเปรียบเทียบ:

Unshuffled          Shuffled            Unshuffled number   Shuffled number
Two of Clubs        Three of Clubs      1                   2
Three of Clubs      Two of Clubs        2                   1
Four of Clubs       Five of Clubs       3                   4
Five of Clubs       Four of Clubs       4                   3

ความสัมพันธ์โดยวิธีเพียร์สันจะเป็น: 0.6

ด้วยชุดการ์ดขนาดใหญ่ (ทั้งหมด 52) คุณอาจเห็นรูปแบบโผล่ออกมา สมมุติฐานของฉันคือว่าหลังจากสับมากขึ้นคุณจะได้ความสัมพันธ์น้อยลง

อย่างไรก็ตามมีหลายวิธีในการวัดความสัมพันธ์

ฉันลองใช้ความสัมพันธ์ของ Pearson แต่ฉันไม่แน่ใจว่านี่เป็นความสัมพันธ์ที่ถูกต้องที่จะใช้ในสถานการณ์นี้หรือไม่

นี่เป็นการวัดสหสัมพันธ์ที่เหมาะสมหรือไม่? มีมาตรการที่เหมาะสมกว่านี้ไหม?

คะแนนโบนัสบางครั้งฉันเห็นข้อมูลประเภทนี้ในผลลัพธ์ของฉัน:

เห็นได้ชัดว่ามีความสัมพันธ์กัน แต่ฉันไม่รู้ว่าคุณวัด 'เส้นแนวโน้ม' แยกกันอย่างไร

คุณสามารถวัดระดับความสัมพันธ์สัมพัทธ์ (หรือแม่นยำยิ่งขึ้นการเพิ่มระดับของการสุ่ม) โดยใช้เอนโทรปีของแชนนอนในความแตกต่างของมูลค่าหน้าไพ่ระหว่างการ์ดทุกคู่ที่อยู่ติดกัน

ต่อไปนี้เป็นวิธีคำนวณสำหรับสำรับไพ่ที่สุ่ม 52 ใบ คุณเริ่มต้นด้วยการวนลูปหนึ่งครั้งผ่านทั้งเด็คและสร้างฮิสโตแกรมเรียงลำดับ สำหรับแต่ละตำแหน่งการ์ด , คำนวณความแตกต่างในมูลค่าที่ตราไว้{i} หากต้องการทำให้เป็นรูปธรรมมากขึ้นสมมติว่าการ์ดในตำแหน่ง th นั้นคือราชาแห่งโพดำและการ์ดในตำแหน่งที่นั้นคือสี่ของสโมสร แล้วเรามีและและ48 เมื่อคุณไปถึงเป็นกรณีพิเศษ คุณวนกลับไปที่จุดเริ่มต้นของเด็คอีกครั้งแล้วนำ$i=1,2,...,52$$\Delta F_{i} = F_{i+1} - F_{i}$$(i+1)$$i$$F_{i+1} = 51$$F_{i} = 3$$\Delta F_{i} = 51-3 = 48$$i=52$$\Delta F_{52} = F_{1} - F_{52}$. หากคุณลงท้ายด้วยจำนวนลบสำหรับใด ๆ ให้เพิ่ม 52 เพื่อนำค่าความแตกต่างของใบหน้ากลับมาอยู่ในช่วง 1-52$\Delta F$

คุณจะพบกับชุดค่าความแตกต่างของใบหน้าสำหรับไพ่คู่กัน 52 คู่โดยแต่ละใบจะอยู่ในช่วงที่อนุญาตตั้งแต่ 1-52 นับความถี่สัมพัทธ์ของสิ่งเหล่านี้โดยใช้ฮิสโตแกรม (เช่นอาร์เรย์หนึ่งมิติ) ที่มี 52 องค์ประกอบ "การแจกแจงความน่าจะเป็นที่สังเกตได้" สำหรับสำรับนั้น คุณสามารถทำให้การกระจายนี้เป็นมาตรฐานโดยการหารจำนวนในแต่ละ bin ด้วย 52 ดังนั้นคุณจะจบลงด้วยชุดของตัวแปรซึ่งแต่ละอันอาจแยกกัน ช่วงของค่าที่เป็นไปได้: {0, 1/52, 2/52, 3/52, ฯลฯ } ทั้งนี้ขึ้นอยู่กับจำนวนความแตกต่างของค่าใบหน้าที่จับคู่แบบสุ่มในแต่ละช่องของฮิสโทแกรม$p_{1}, p_{2}, ... p_{52}$

เมื่อคุณมีฮิสโตแกรมคุณสามารถคำนวณเอนโทรปีของแชนนอนสำหรับการวนซ้ำแบบสุ่มเป็น

$$E = \sum_{k=1}^{52} -p_{k} ln(p_{k})$$ ฉันเขียนแบบจำลองขนาดเล็กใน R เพื่อแสดงผลลัพธ์ พล็อตแรกแสดงให้เห็นว่าเอนโทรปีมีการพัฒนาอย่างไรในการวนซ้ำ 20 ครั้ง ค่า 0 เกี่ยวข้องกับดาดฟ้าที่มีการเรียงลำดับอย่างสมบูรณ์ ค่าที่มากขึ้นหมายถึงสำรับที่มีความยุ่งเหยิงมากขึ้นหรือมีความเกี่ยวข้องมากขึ้น พล็อตที่สองแสดงให้เห็นถึงชุดของ 20 แง่มุมแต่ละคนมีพล็อตที่คล้ายกับที่เดิมรวมอยู่กับคำถามแสดงบัตรสับเพื่อเปรียบเทียบกับลำดับบัตรเริ่มต้น 20 แง่มุมในพล็อตที่ 2 นั้นเหมือนกับ 20 การวนซ้ำในพล็อตแรกและพวกมันยังมีรหัสสีเหมือนกันเช่นกัน เรียงลำดับ รหัสการจำลองที่สร้างแปลงถูกผนวกเข้าท้าย

library(ggplot2)

# Number of cards
ncard <- 52 
# Number of shuffles to plot
nshuffle <- 20
# Parameter between 0 and 1 to control randomness of the shuffle
# Setting this closer to 1 makes the initial correlations fade away
# more slowly, setting it closer to 0 makes them fade away faster
mixprob <- 0.985 
# Make data frame to keep track of progress
shuffleorder <- NULL
startorder <- NULL
iteration <- NULL
shuffletracker <- data.frame(shuffleorder, startorder, iteration)

# Initialize cards in sequential order
startorder <- seq(1,ncard)
shuffleorder <- startorder

entropy <- rep(0, nshuffle)
# Loop over each new shuffle
for (ii in 1:nshuffle) {
    # Append previous results to data frame
    iteration <- rep(ii, ncard)
    shuffletracker <- rbind(shuffletracker, data.frame(shuffleorder,
                            startorder, iteration))
    # Calculate pairwise value difference histogram
    freq <- rep(0, ncard)
    for (ij in 1:ncard) {
        if (ij == 1) {
            idx <- shuffleorder[1] - shuffleorder[ncard]
        } else {
            idx <- shuffleorder[ij] - shuffleorder[ij-1]
        }
        # Impose periodic boundary condition
        if (idx < 1) {
            idx <- idx + ncard
        }
        freq[idx] <- freq[idx] + 1
    }
    # Sum over frequency histogram to compute entropy
    for (ij in 1:ncard) {
        if (freq[ij] == 0) {
            x <- 0
        } else {
            p <- freq[ij] / ncard
            x <- -p * log(p, base=exp(1))
        }
        entropy[ii] <- entropy[ii] + x
    }
    # Shuffle the cards to prepare for the next iteration
    lefthand <- shuffleorder[floor((ncard/2)+1):ncard]
    righthand <- shuffleorder[1:floor(ncard/2)]
    ij <- 0
    ik <- 0
    while ((ij+ik) < ncard) {
        if ((runif(1) < mixprob) & (ij < length(lefthand))) {
            ij <- ij + 1
            shuffleorder[ij+ik] <- lefthand[ij]
        }
        if ((runif(1) < mixprob) & (ik < length(righthand))) {
            ik <- ik + 1
            shuffleorder[ij+ik] <- righthand[ik]
        }
    }
}
# Plot entropy vs. shuffle iteration
iteration <- seq(1, nshuffle)
output <- data.frame(iteration, entropy)
print(qplot(iteration, entropy, data=output, xlab="Shuffle Iteration", 
            ylab="Information Entropy", geom=c("point", "line"),
            color=iteration) + scale_color_gradient(low="#ffb000",
            high="red"))

# Plot gradually de-correlating sort order
dev.new()
print(qplot(startorder, shuffleorder, data=shuffletracker, color=iteration,
            xlab="Start Order", ylab="Shuffle Order") + facet_wrap(~ iteration,
            ncol=4) + scale_color_gradient(low="#ffb000", high="red"))

ฉันรู้ว่าโพสต์นี้อายุเกือบ 4 ปี แต่ฉันเป็น cryptanalyst อดิเรกและได้รับการศึกษายันต์บัตรเล่น เป็นผลให้ฉันกลับมาที่โพสต์นี้ซ้ำแล้วซ้ำอีกเพื่ออธิบายสำสับไพ่ในฐานะที่มาของเอนโทรปีสำหรับการสุ่มคีย์สำรับ ในที่สุดฉันตัดสินใจที่จะตรวจสอบคำตอบโดย stachyra โดยการสับสำรับด้วยมือและประเมินเอนโทรปีของสำรับหลังจากการสับแต่ละครั้ง

TL; DR เพื่อเพิ่มเอนโทรปีของสำรับ:

• สำหรับการสับแบบระลอกคลื่นเท่านั้นคุณต้องมีการสับ 11-12
• สำหรับการตัดที่ดาดฟ้าก่อนจากนั้นจึงทำการสับแบบระลอกคลื่นคุณต้องใช้การตัดและสับ 6-7 ครั้งเท่านั้น

ก่อนอื่นทุกอย่างที่ stachyra กล่าวถึงสำหรับการคำนวณเอนโทรปีของแชนนอนนั้นถูกต้อง สามารถต้มด้วยวิธีนี้:

1. กำหนดค่าที่เป็นเอกลักษณ์ให้กับไพ่ 52 ใบในสำรับแต่ละใบ
2. สุ่มดาดฟ้า
3. สำหรับ n = 0 ถึง n = 51 ให้บันทึกแต่ละค่าของ (n - (n + 1) mod 52) mod 52
4. นับจำนวนการเกิดขึ้นของ 0, 1, 2, ... , 49, 50, 51
5. ทำให้ปกติบันทึกเหล่านั้นโดยการหารด้วย 52
6. สำหรับ i = 1 ถึง i = 52 ให้คำนวณ -p_i * log (p_i) / log (2)
7. รวมค่า

ที่ stachyra ทำให้สมมติฐานหนึ่งที่ลึกซึ้งคือการใช้การสับเปลี่ยนคนในโปรแกรมคอมพิวเตอร์จะมาพร้อมกับสัมภาระบางส่วน ด้วยการเล่นไพ่แบบใช้กระดาษน้ำมันจากมือของคุณจะถูกส่งไปยังการ์ด เมื่อเวลาผ่านไปนานขึ้นเนื่องจากการสะสมน้ำมันการ์ดจะเริ่มเกาะติดกันและสิ่งนี้จะจบลงในการสลับของคุณ ยิ่งมีการใช้สำรับมากเท่าไหร่ไพ่ที่อยู่ติดกันสองใบหรือมากกว่าจะติดกันและยิ่งเกิดขึ้นบ่อยขึ้น

ยิ่งกว่านั้นสมมุติว่าทั้งสองสโมสรและแจ็คของหัวใจติดกัน พวกเขาอาจติดกันด้วยกันในระหว่างการสับของคุณโดยไม่แยก สิ่งนี้สามารถเลียนแบบได้ในโปรแกรมคอมพิวเตอร์ แต่นี่ไม่ใช่กรณีของรูทีน R ของ stachyra

นอกจากนี้ stachyra ยังมีตัวแปรการจัดการ "mixprob" โดยไม่เข้าใจตัวแปรนี้อย่างสมบูรณ์มันเป็นกล่องดำเล็กน้อย คุณตั้งค่าไม่ถูกต้องซึ่งส่งผลต่อผลลัพธ์ ดังนั้นฉันต้องการทำให้แน่ใจว่าสัญชาตญาณของเขาถูกต้อง ดังนั้นฉันจึงตรวจสอบด้วยมือ

ฉันสับไพ่ 20 ครั้งด้วยมือในสองกรณีที่แตกต่างกัน (40 สับทั้งหมด) ในตัวอย่างแรกฉันเพียงแค่ระลอกคลื่นน้อย ๆ ทำให้การตัดขวาและซ้ายใกล้เคียงกัน ในตัวอย่างที่สองฉันตัดดาดฟ้าโดยเจตนาให้ห่างจากกลางดาดฟ้า (1/3, 2/5, 1/4 และอื่น ๆ ) ก่อนที่จะทำการตัดให้สม่ำเสมอสำหรับการสลับแบบ riffle ความรู้สึกของฉันในกรณีที่สองคือโดยการตัดดาดฟ้าก่อนที่จะสับและอยู่ห่างจากตรงกลางฉันสามารถแนะนำการแพร่กระจายสู่สำรับได้เร็วกว่าการสลับสับเปลี่ยนหุ้น

นี่คือผลลัพธ์ ขั้นแรกให้สับแบบระลอกคลื่นตรง:

และนี่คือการตัดดาดฟ้ารวมกับการสับแบบ riffle:

ดูเหมือนว่าเอนโทรปีจะถูกขยายให้ใหญ่สุดในเวลาประมาณ 1/2 เวลาของการเรียกร้องโดย stachyra ยิ่งไปกว่านั้นสัญชาตญาณของฉันถูกต้องที่ตัดดาดฟ้าจงใจให้ห่างจากกลางก่อนก่อนที่การสับแบบระลอกคลื่นน้อยทำให้เกิดการแพร่กระจายมากขึ้นในสำรับ อย่างไรก็ตามหลังจากประมาณ 5 สับมันไม่ได้มีความสำคัญอีกต่อไปแล้ว คุณจะเห็นว่าหลังจากนั้นประมาณ 6-7 ชัฟเฟิลเอนโทรปีจะถูกขยายให้ใหญ่สุดเทียบกับ 10-12 เพราะข้ออ้างทำให้ stachyra ของฉัน เป็นไปได้หรือไม่ว่า 7 shuffles นั้นเพียงพอหรือฉันตาบอด

คุณสามารถเห็นข้อมูลของฉันที่ Google ชีต เป็นไปได้ว่าฉันบันทึกการ์ดเล่นหรือสองอย่างไม่ถูกต้องดังนั้นฉันจึงไม่สามารถรับประกันความถูกต้องได้ 100% กับข้อมูล

เป็นสิ่งสำคัญที่การค้นพบของคุณจะได้รับการตรวจสอบอย่างอิสระเช่นกัน แบรดแมนน์จากภาควิชาคณิตศาสตร์ของมหาวิทยาลัยฮาร์วาร์ดศึกษาว่าต้องใช้กี่ครั้งในการสับไพ่ก่อนที่ความสามารถในการคาดการณ์ของการ์ดใด ๆ ในสำรับจะไม่สามารถคาดเดาได้อย่างสมบูรณ์ (แชนนอนเอนโทรปีนั้นขยายใหญ่สุด) ผลลัพธ์ของเขาสามารถพบได้ใน PDF 33 หน้านี้

สิ่งที่น่าสนใจจากการค้นพบของเขาคือจริง ๆ แล้วเขากำลังตรวจสอบบทความ 1990 New York Times โดย Persi Diaconisซึ่งอ้างว่า 7 shuffles เพียงพอสำหรับการผสมสำรับไพ่ผ่านการสลับแบบ riffle อย่างละเอียด

แบรดแมนน์เดินผ่านแบบจำลองทางคณิตศาสตร์ที่แตกต่างกันสองสามแบบในการสับรวมทั้งเชนมาร์คอฟและมาถึงข้อสรุปดังต่อไปนี้:

นี่คือประมาณ 11.7 สำหรับ n = 52 ซึ่งหมายความว่าตามมุมมองนี้เราคาดว่าโดยเฉลี่ย 11 หรือ 12 สับจะจำเป็นสำหรับการสุ่มไพ่จริง โปรดทราบว่านี่มีขนาดใหญ่กว่า 7 อย่างมาก

แบรดแมนน์เพิ่งตรวจสอบผลลัพธ์ของ stachyra อย่างอิสระ แต่ไม่ใช่ของฉัน ดังนั้นฉันจึงดูข้อมูลของฉันให้ละเอียดยิ่งขึ้นและฉันค้นพบว่าทำไม 7 ชัฟเฟิลไม่เพียงพอ ก่อนอื่นค่าเอนโทรปีสูงสุดของแชนนอนเป็นบิตสำหรับการ์ดใด ๆ ในสำรับคือ log (52) / log (2) ~ = 5.7 บิต แต่ข้อมูลของฉันไม่แตกเกิน 5 บิต อยากรู้ว่าฉันสร้างอาร์เรย์จำนวน 52 องค์ประกอบใน Python โดยสับอาร์เรย์นั้น:

>>> import random
>>> r = random.SystemRandom()
>>> d = [x for x in xrange(1,52)]
>>> r.shuffle(d)
>>> print d
[20, 51, 42, 44, 16, 5, 18, 27, 8, 24, 23, 13, 6, 22, 19, 45, 40, 30, 10, 15, 25, 37, 52, 34, 12, 46, 48, 3, 26, 4, 1, 38, 32, 14, 43, 7, 31, 50, 47, 41, 29, 36, 39, 49, 28, 21, 2, 33, 35, 9, 17, 11]

การคำนวณเอนโทรปีต่อบัตรให้ผลประมาณ 4.8 บิต การทำเช่นนี้เป็นสิบครั้งหรือมากกว่านั้นจะแสดงผลลัพธ์ที่คล้ายกันซึ่งแตกต่างกันระหว่าง 5.2 บิตและ 4.6 บิตโดยมีค่าเฉลี่ย 4.8 ถึง 4.9 ดังนั้นการดูค่าเอนโทรปีแบบดิบของข้อมูลของฉันไม่เพียงพอมิฉะนั้นฉันสามารถเรียกมันได้ดีที่ 5 shuffles

เมื่อฉันดูข้อมูลของฉันอย่างใกล้ชิดฉันสังเกตเห็นจำนวน "ศูนย์ที่เก็บข้อมูล" เหล่านี้คือที่เก็บซึ่งไม่มีข้อมูลสำหรับการลบระหว่างการ์ดใบหน้าสำหรับหมายเลขนั้น ตัวอย่างเช่นเมื่อลบค่าของไพ่สองใบที่อยู่ติดกันจะไม่มีผลลัพธ์ "15" หลังจากคำนวณเดลตาทั้งหมด 52 รายการ

ฉันเห็นว่าในที่สุดมันก็จะตกลงประมาณ 17-18 "ศูนย์ถัง" ประมาณ 11-12 สับ แน่นอนว่าสำรับที่สับของฉันผ่าน Python เฉลี่ย 17-18 "zero buckets" ด้วยค่าสูง 21 และต่ำจาก 14 ทำไม 17-18 เป็นผลลัพธ์ที่ตัดสินฉันยังอธิบายไม่ได้ ... แต่ดูเหมือนว่าฉันต้องการเอนโทรปีทั้งสอง ~ 4.8 บิตและ 17 "ศูนย์ถัง"

ด้วยการสลับสับเปลี่ยนหุ้นของฉันนั่นคือ 11-12 สับ ด้วยการตัดและสับเปลี่ยนของฉันนั่นคือ 6-7 ดังนั้นเมื่อพูดถึงเกมฉันขอแนะนำให้ใช้แบบตัดและสับ ไม่เพียง แต่รับประกันว่าการ์ดด้านบนและล่างจะถูกผสมลงในสำรับในการสับเปลี่ยนแต่ละครั้ง แต่ก็ยังเร็วกว่า 11-12 ในการสับไพ่ ฉันไม่รู้เกี่ยวกับคุณ แต่เมื่อฉันเล่นเกมไพ่กับครอบครัวและเพื่อน ๆ พวกเขาไม่อดทนพอที่ฉันจะเล่น shuffles 12 อัน