社区首页 >专栏 >数学杂谈：限制条件下的均匀分布考察

数学杂谈：限制条件下的均匀分布考察

codename_cys

发布于 2022-11-29 09:56:48

73300

代码可运行

文章被收录于专栏：我的充电站我的充电站

运行总次数：0

代码可运行

数学杂谈：限制条件下的均匀分布考察

1. 问题描述

假设

x_{1}, . . ., x_{n}

$x_1, ..., x_n$

均为

0 \sim 1

$0 \sim 1$

上的均匀分布，且满足限制条件：

x_{1} + x_{2} + . . . + x_{n} = 1

$x_1 + x_2 + ... + x_n = 1$

求此时

x_{i}

$x_i$

的真实分布表达式。

2. 问题解答

1. 答案

限制条件下

x

$x$

的密度函数表达式如下：

f_{n} (x) = (n - 1) \cdot (1 - x)^{n - 2}

$f_n(x) = (n-1) \cdot (1-x)^{n-2}$

2. 解析

我们可以快速地给出推导公式为：

f_{n} (x) = \frac{\int_{0}^{1 - x} d t_{1} \int_{0}^{1 - x - t_{1}} d t_{2} . . . \int_{0}^{1 - x - t_{1} - . . . - t_{n - 3}} d t_{n - 2}}{\int_{0}^{1} d t_{1} \int_{0}^{1 - t_{1}} d t_{2} . . . \int_{0}^{1 - t_{1} - . . . - t_{n - 2}} d t_{n - 1}}

$f_n(x) = \frac{\int_{0}^{1-x}dt_1 \int_{0}^{1-x-t_1}dt_2 ... \int_{0}^{1-x-t_1-...-t_{n-3}}dt_{n-2}}{\int_{0}^{1}dt_1 \int_{0}^{1-t_1}dt_2 ... \int_{0}^{1-t_1-...-t_{n-2}}dt_{n-1}}$

令

g_{n} (x) = \int_{0}^{1 - x} d t_{1} \int_{0}^{1 - x - t_{1}} d t_{2} . . . \int_{0}^{1 - x - t_{1} - . . . - t_{n - 1}} d t_{n}

$g_n(x) = \int_{0}^{1-x}dt_1 \int_{0}^{1-x-t_1}dt_2 ... \int_{0}^{1-x-t_1-...-t_{n-1}}dt_{n}$

则我们有：

f_{n} (x) = g_{n - 2} (x) / g_{n - 1} (0)

$f_n(x) = g_{n-2}(x) / g_{n-1}(0)$

而

g_{n} (x)

$g_{n}(x)$

我们可以通过递归关系

g_{n} (x) = \int_{0}^{1 - x} g_{n - 1} (1 - x - t_{1}) d t_{1}

$g_n(x) = \int_{0}^{1-x} g_{n-1}(1-x-t_1) dt_1$

快速计算得到：

g_{n} (x) = \frac{1}{n!} (1 - x)^{n}

$g_n(x) = \frac{1}{n!}(1-x)^{n}$

因此，我们即可解得：

f_{n} (x) = (n - 1) \cdot (1 - x)^{n - 2}

$f_n(x) = (n-1) \cdot (1-x)^{n-2}$

特别地，积分即可快速得到，某一个元素要取值得到至少

τ

$\tau$

的概率为：

P (x \geq τ) = (1 - τ)^{n - 1}

$P(x \geq \tau) = (1-\tau)^{n-1}$

。

3. 蒙特卡洛模拟

如果我们要对上述结论进行验证，我们可以使用蒙特卡洛模拟来对上述结论进行验证。

我们直接给出代码如下：

import numpy as np
from random import random
from matplotlib import pyplot as plt

def monte_carlo_simulate(n=5, N=10000):
    s = []
    for _ in range(N):
        while True:
            tmp = [random() for _ in range(n-1)]
            if sum(tmp) <= 1:
                s.append(1 - sum(tmp))
                break
    return s

def show_simulate(n=5, N=10000):
    x = np.linspace(0, 1, num=100)
    y = (n-1) * np.pow(1-x, n-2)
    s = monte_carlo_simulate(n=n, N=N)
    plt.figure(figsize=(15, 7))
    plt.hist(s, bins=100, range=[0, 1], density=True)
    plt.plot(x, y)
    plt.show()
    return

show_simulate(n=5, N=10000)

可以看到：

进一步的，如果我们要快速地获取符合

x

$x$

分布的随机数，也只需要做如下构造即可：

import math
from random import random

def random(k=5):
    x = random()
    z = 1 - math.pow(z, 1/(k-1))
    return z

3. 离散情况延拓

下面，我们稍微拓展一下，如果

x

$x$

不连续，是离散的情况下，那么结果如何。

我们修改问题为：

假设我们有

k

$k$

个均匀分布的离散项，取值范围为

0 \sim N

$0 \sim N$

，且满足限制条件

x_{1} + x_{2} + . . . x_{k} = N

$x_1 + x_2 + ... x_k = N$

，那么其中

x_{1}

$x_1$

不小于

M

$M$

的概率是多少。

这个问题其实感觉比上述连续的情况还要简单一些，我们只需要将其视为排列组合问题即可进行解答，即视为分堆问题，将

N

$N$

个元素分到

k

$k$

个堆当中，令其中某一个堆中的元素个数不少于

M

$M$

。

1. 正整数的情况

首先，我们来考察一下最简单的情况，即要求每个堆中至少有一个元素，且

N, M

$N,M$

均为有限整数。

此时，我们要做的事实上就是在

N

$N$

个元素所构成的

N - 1

$N-1$

个间隔位置当中放入

k - 1

$k-1$

个挡板。不妨设要求的堆就是第一个堆，即第一个堆的元素个数不少于

M

$M$

个，此时，符合要求的摆放方式必然要求第一个挡板的出现位置必须要在第

M

$M$

个间隔或者之后。

因此，我们可以得到答案为：

P (x_{1} \geq M) = \frac{C_{N - M}^{k - 1}}{C_{N - 1}^{k - 1}}

$P(x_1 \geq M) = \frac{C_{N-M}^{k-1}}{C_{N-1}^{k-1}}$

2. 整数的情况

对于整数的情况，其结果本质上是与之前正数的情况完全相同的，唯一的区别在于，挡板可以相邻，因此，我们事实上就是将

N

$N$

个元素与

k - 1

$k-1$

个挡板合在一起进行排列组合。

同样的，我们要求第一个堆当中至少包含

M

$M$

个元素，此时我们可以仿上求得答案为：

P (x_{1} \geq M) = \frac{C_{N - M + k - 1}^{k - 1}}{C_{N + k - 1}^{k - 1}}

$P(x_1 \geq M) = \frac{C^{k-1}_{N-M+k-1}}{C^{k-1}_{N+k-1}}$

3.

N \to \infty

$N \to \infty$

的情况

最后，我们考察一下

N \to \infty

$N \to \infty$

的情况，令

N \to \infty

$N \to \infty$

，且有

l i m N \to \infty \frac{M}{N} = τ

$\mathop{lim}\limits_{N\to \infty} \frac{M}{N} = \tau$

。

此时，上述两个式子的解收敛为：

l i m N \to \infty P (x_{1} \geq M) = (1 - τ)^{k - 1}

$\mathop{lim}\limits_{N\to \infty} P(x_1 \geq M) = (1-\tau)^{k-1}$

此结果就是之前讨论的连续情况下的解。

4. 误区分析

这里，其实有一个坑要注意一下，就是如果你在模拟的时候这么写作函数：

def simulate(n=5, N=10000):
    s = []
    for _ in range(N):
        t = 1.0
        for _ in range(n-1):
            t -= t * random()
        s.append(t)
    return s