Question

所以，我前几天在Hacker News上看到了这个：http://web.mit.edu/tee/www/bertrand/problem.html

它基本上表示半径为1的圆上的随机和弦长度大于3的平方根的概率是多少。

看着它，很明显答案是1/3，但对HN的评论让人比我更聪明地辩论这个问题。 https://news.ycombinator.com/item?id=10000926

我不想辩论，但我确实想确保自己并不疯狂。所以我编码了我认为会证明它是P = 1/3，但我最终得到P~.36。所以，我的代码有些不对劲。

我可以进行健全检查吗？

    package com.jonas.betrand;

    import java.awt.geom.Point2D;
    import java.util.Random;

    public class Paradox {
        final static double ROOT_THREE = Math.sqrt(3);

        public static void main(String[] args) {
            int greater = 0;
            int less = 0;
            for (int i = 0; i < 1000000; i++) {
                Point2D.Double a = getRandomPoint();
                Point2D.Double b = getRandomPoint();

                //pythagorean
                if (Math.sqrt(Math.pow((a.x - b.x), 2) + Math.pow((a.y - b.y), 2)) > ROOT_THREE) {
                    greater++;
                } else {
                    less++;
                }   
            }
            System.out.println("Probability Observerd: " + (double)greater/(greater+less));
        }

        public static Point2D.Double getRandomPoint() {
            //get an x such that -1 < x < 1
            double x = Math.random();
            boolean xsign = new Random().nextBoolean();
            if (!xsign) {
                x *= -1;
            }

            //formula for a circle centered on origin with radius 1: x^2 + y^2 = 1
            double y = Math.sqrt(1 - (Math.pow(x, 2)));
            boolean ysign = new Random().nextBoolean();
            if (!ysign) {
                y *= -1;
            }

            Point2D.Double point = new Point2D.Double(x, y);
            return point;
        }
    }

编辑：感谢一群人让我直截了当，我发现我找到随机点的方法并不是那么随意。这是该函数的修复，返回约1/3。

        public static Point2D.Double getRandomPoint() {
            //get an x such that -1 < x < 1
            double x = Math.random();
            Random r = new Random();
            if (!r.nextBoolean()) {
                x *= -1;
            }

            //circle centered on origin: x^2 + y^2 = r^2. r is 1. 
            double y = Math.sqrt(1 - (Math.pow(x, 2)));
            if (!r.nextBoolean()) {
                y *= -1;
            }

            if (r.nextBoolean()) {
                return new Point2D.Double(x, y);
            } else {
                return new Point2D.Double(y, x);
            }
        }

Answer 1

我相信你需要假设一个固定点说（0,1），然后在圆周围的[0,2 * pi]中选择一个随机的旋转量，用于和弦的第二个点的位置。 / p>

只是为了它的地狱我在Swift中写了不正确的版本（学习Swift！）：

    struct P {
        let x, y: Double
        init() {
            x = (Double(arc4random()) / 0xFFFFFFFF) * 2 - 1
            y = sqrt(1 - x * x) * (arc4random() % 2 == 0 ? 1 : -1)
        }
        func dist(other: P) -> Double {
            return sqrt((x - other.x) * (x - other.x) + (y - other.y) * (y - other.y))
        }
    }
    let root3 = sqrt(3.0)
    let total = 100_000_000
    var samples = 0
    for var i = 0; i < total; i++ {
        if P().dist(P()) > root3 {
            samples++
        }
    }
    println(Double(samples) / Double(total))

答案确实是0.36。正如评论所解释的那样，随机X值更有可能选择＆＃34;展平区域＆＃34;在pi / 2附近并且极不可能选择＆＃34;垂直挤压＆＃34;大约0和pi的区域。

但是在P的构造函数中很容易修复：（Double(arc4random()) / 0xFFFFFFFF对于[0,1）中的随机浮点数而言很有说服力。

        let angle = Double(arc4random()) / 0xFFFFFFFF * M_PI * 2
        x = cos(angle)
        y = sin(angle)
        // outputs 0.33334509

Answer 2

伯特兰德的悖论恰恰是：一个悖论。根据问题的解释方式，答案可以被认为是1/3或1/2。看起来你采用随机和弦方法，其中线的一侧是固定的，然后你随机的和弦绘制到圆的任何部分。使用这种方法，绘制长度超过sqrt（3）的和弦的几率确实是1/3。

但是如果你使用不同的方法，我会称之为随机半径方法，你会发现它可以是1/2！随机半径就是这个，你在圆圈中绘制一个半径，然后你取一个随机的和弦，这个半径一分为二。此时，随机和弦将比sqrt（3）1/2更长。

最后，随机中点方法。选择圆圈中的随机点，然后将此随机点作为和弦的中点绘制一个和弦。如果此点落在半径1/2的同心圆内，则弦长短于sqrt（3）。如果它落在同心圆之外，则它比sqrt（3）长。半径为1/2的圆具有半径为1的圆的1/4，因此和弦小于sqrt（3）的几率为1/4。

关于你的代码，我还没有时间去研究它，但希望这澄清了悖论（这只是一个不完整的问题，实际上并不是一个悖论）：D

Answer 3

我会辩称，贝特朗悖论不是概率的悖论，而是警告性的教训。确实是在问一个问题：随机是什么意思？

伯特兰认为，有三种自然但不同的方法来随机选择和弦，给出三个不同的答案。但是，当然还有其他随机方法，但是可以说这些方法不是最自然的方法（也就是说，不是第一个想到的方法）。例如，我们可以以非均匀的方式随机放置两个和弦端点。或者，我们根据某些不均匀的密度来定位和弦中点，例如截断的二元法线。

要使用一种编程语言模拟这三种方法，您需要能够在单位间隔上生成统一的随机变量，这是所有标准（伪）随机数生成器都应执行的操作。对于其中一种方法/解决方案（随机中点），您必须采用统一随机变量之一的平方根。然后，您将随机变量乘以适当的因子（或重新缩放）。然后，对于每种仿真方法（或解决方案），某些几何图形都会给出两个端点的表达式。

有关更多详细信息，我已经写了一个post关于这个问题。我建议在该帖子结尾的进一步阅读部分下引用的链接和书籍。例如，请参阅this一套新的已发布的讲义中的第1.3节。艾萨克（Esaac）在概率的乐趣中也提到了Bertrand悖论。克拉克（Clark）在从A到Z的悖论一书中以非数学的方式对此进行了介绍。

我还用MATLAB，R和Python上传了一些仿真代码，可以在here中找到它们。

例如，在Python（带有NumPy）中：

import numpy as np; #NumPy package for arrays, random number generation, etc
import matplotlib.pyplot as plt #for plotting
from matplotlib import collections  as mc #for plotting line chords      

###START Parameters START###
#Simulation disk dimensions
xx0=0; yy0=0; #center of disk
r=1; #disk radius
numbLines=10**2;#number of lines
###END Parameters END###

###START Simulate three solutions on a disk START###
#Solution A
thetaA1=2*np.pi*np.random.uniform(0,1,numbLines); #choose angular component uniformly
thetaA2=2*np.pi*np.random.uniform(0,1,numbLines); #choose angular component uniformly

#calculate chord endpoints
xxA1=xx0+r*np.cos(thetaA1);
yyA1=yy0+r*np.sin(thetaA1);
xxA2=xx0+r*np.cos(thetaA2);
yyA2=yy0+r*np.sin(thetaA2);
#calculate midpoints of chords
xxA0=(xxA1+xxA2)/2; yyA0=(yyA1+yyA2)/2;

#Solution B
thetaB=2*np.pi*np.random.uniform(0,1,numbLines); #choose angular component uniformly
pB=r*np.random.uniform(0,1,numbLines); #choose radial component uniformly
qB=np.sqrt(r**2-pB**2); #distance to circle edge (alonge line)

#calculate trig values
sin_thetaB=np.sin(thetaB);
cos_thetaB=np.cos(thetaB);

#calculate chord endpoints
xxB1=xx0+pB*cos_thetaB+qB*sin_thetaB;
yyB1=yy0+pB*sin_thetaB-qB*cos_thetaB;
xxB2=xx0+pB*cos_thetaB-qB*sin_thetaB;
yyB2=yy0+pB*sin_thetaB+qB*cos_thetaB;
#calculate midpoints of chords
xxB0=(xxB1+xxB2)/2; yyB0=(yyB1+yyB2)/2;

#Solution C
#choose a point uniformly in the disk
thetaC=2*np.pi*np.random.uniform(0,1,numbLines); #choose angular component uniformly
pC=r*np.sqrt(np.random.uniform(0,1,numbLines)); #choose radial component
qC=np.sqrt(r**2-pC**2); #distance to circle edge (alonge line)

#calculate trig values
sin_thetaC=np.sin(thetaC);
cos_thetaC=np.cos(thetaC);

#calculate chord endpoints
xxC1=xx0+pC*cos_thetaC+qC*sin_thetaC;
yyC1=yy0+pC*sin_thetaC-qC*cos_thetaC;
xxC2=xx0+pC*cos_thetaC-qC*sin_thetaC;
yyC2=yy0+pC*sin_thetaC+qC*cos_thetaC;
#calculate midpoints of chords
xxC0=(xxC1+xxC2)/2; yyC0=(yyC1+yyC2)/2;
###END Simulate three solutions on a disk END###

伯特兰的悖论模拟

3 个答案: