Как найти среднее число испытаний

При большом числе испытаний $n$ и малой вероятности $р$ формулой Бернулли пользоваться неудобно, например, $0.97^{999}$ вычислить трудно. В этом случае для вычисления вероятности того, что в $n$ испытаниях ($n$ – велико) событие произойдет $k$ раз, используют формулу Пуассона:

$$
P_n(k)=frac{lambda^k}{k!}cdot e^{-lambda}.
$$

Здесь $lambda=n cdot p$ обозначает среднее число появлений события в $n$ испытаниях.

Эта формула дает удовлетворительное приближение для $p le 0,1$ и $np le 10$. Cобытия, для которых применима формула Пуассона, называют редкими, так как вероятность их осуществления очень мала (обычно порядка 0,001-0,0001).

При больших $np$ рекомендуется применять формулы Лапласа (Муавра-Лапласа).

Бесплатный онлайн-калькулятор для формулы Пуассона

Примеры решений на формулу Пуассона

Несколько опытов
называют независимыми, если вероятность
того или иного исхода каждого из опытов
не зависит от исходов других опытов.

Пусть вероятность
появления события A
во всех независимых опытах одна и та же
и равна р.
В таком случае, вероятность появления
события A
в n
опытах m
раз определяется по формуле Бернулли:

(2.6)

Пример 1.

Монета брошена 4
раза. Определить вероятность того, что
герб выпадет
2 раза. Вероятность
появления герба в каждом опыте p
= 0,5.

Решение.

Если число испытаний
велико, а вероятность появления события
Р в каждом испытании очень мала,
пользуются формулой Пуассона:

,
(2.7)

где m
– число
появлений события в n
испытаниях;

– среднее число
появлений события в n
испытаниях.

Формула Пуассона
именуется законом редких явлений.

Пример 2.

В учебном заведении
обучаются 730 студентов. Вероятность
того, что день рождения наугад взятого
по списку студента приходится на
определенный день года
–

для каждого из 365 дней. Найти вероятность
того, что найдется 3 студента,
имеющих один и тот же день рождения.

Решение.

Если число
независимых опытов n
в формуле Бернулли велико, пользуются
асимптотической формулой Лапласа:

,
(2.8)

где

Пример 3.

Найти вероятность
того, что событие А наступит 80 раз в 400
испытаниях, если вероятность появления
этого события в каждом испытании равна
0,2.

Решение.

n
= 400, m
= 80, p
= 0.2, 1 – p
= 0.8,

Если вероятность
p
наступления события А в каждом испытании
постоянна и отличается от 0 и 1, то
вероятность

того, что событие А появится в n
испытаниях от К₁
до К₂
раз, приближенно равна определенному
интегралу:

(2.9)

где

и

–
интегралы Лапласа, величины интегралов
определяются по таблице.

Пример 4.

Вероятность того,
что деталь не прошла проверки ОТК, равна
0,2. Найти вероятность того, что среди
400 случайно отобранных деталей окажутся
непроверенными от 70 до 100 деталей.

p
= 0.2; 1 –
p
= 0.8; n
= 400; K₁
= 70; K₂
= 100.

2.5. Простейший поток событий

Потоком событий
называется последовательность событий,
которые наступают в случайные моменты
времени.

Простейшим
(Пуассоновским) называют поток событий,
обладающий свойствами стационарности,
отсутствия последействия, ординарности.

Свойство
стационарности состоит в том, что
вероятность появления событий не зависит
от выбора отсчета времени.

Свойство
отсутствия последействия заключается
в том, что предыстория потока не
сказывается на вероятности появления
события в ближайшем будущем.

Ординарность
потока означает, что вероятность
появления двух событий одновременно
отсутствует

Интенсивностью
потока 
называется среднее число событий,
которые появляются в единицу времени.

Если интенсивность
потока постоянна, то вероятность
появления К
событий простейшего потока за время t
определяется формулой Пуассона:

(2.10)

Пример 1.

Среднее
число заказов такси, поступающих на
диспетчерский пункт за одну минуту,
равно трем. Найти вероятность того, что
за две минуты поступит 4 вызова.

Решение.

 = 3; t
= 2 минуты; К
= 4.

Соседние файлы в предмете [НЕСОРТИРОВАННОЕ]

• #
• #
• #
• #
• #
• #
• #
• #
• #
• #
• #

Макеты страниц

Your process can be described as a Markov chain with a finite number of states, and an absorbing state.

The number of steps before reaching the absorbing state is called the hitting time. The expected hitting time can be calculated easily from the transition matrix of the Markov chain.

• Enumerate all possible states (a, b, c, d, e, f). Consider only a finite number of states, because “b >= 3” is effectively the same as “b = 3”, etc. The total number of states is (1+1)*(3+1)*(0+1)*(2+1)*(3+1) = 192.

• Make sure that in your enumeration, starting state (0, 0, 0, 0, 0, 0) comes first, with index 0, and absorbing state (1, 3, 0, 1, 2, 3) comes last.

• Build the transition matrix P. It’s a square matrix with one row and column per state. Entry P[i, j] in the matrix gives the probability of going from state i to state j when rolling a die. There should be at most 6 non-zero entries per row.

• For example, if i is the index of state (1, 0, 0, 1, 2, 2) and j the index of state (1, 1, 0, 1, 2, 2), then P[i, j] = probability of rolling face B = 0.05. Another example: if i is the index of state (1,3,0,0,0,0), then P[i,i] = probability of rolling A, B or C = 0.25+0.05+0.2 = 0.5.

• Call Q the square matrix obtained by removing the last row and last column of P.

• Call I the identity matrix of the same dimensions as Q.

• Compute matrix M = (I - Q)^-1, where ^-1 is matrix inversion.

• In matrix M, the entry M[i, j] is the expected number of times that state j will be reached before the absorbing state, when starting from state i.

• Since our experiment starts in state 0, we’re particularly interested in row 0 of matrix M.

• The sum of row 0 of matrix M is the expected total number of states reached before the absorbing state. That is exactly the answer we seek: the number of steps to reach the absorbing state.

To understand why this works, you should read a course on Markov chains! Perhaps this one: James Norris’ course notes on Markov chains. The chapter about “hitting times” (which is the name for the number of steps before reaching target state) is chapter 1.3.

Below, an implementation in python.

from itertools import product, accumulate
from operator import mul
from math import prod
import numpy as np

dice_weights = [0.25, 0.05, 0.2, 0.15, 0.2, 0.15]
targets = [1, 3, 0, 1, 2, 3]

def get_expected_n_trials(targets, dice_weights):
    states = list(product(*(range(n+1) for n in targets)))
    base = list(accumulate([n+1 for n in targets[:0:-1]], mul, initial=1))[::-1]
    lookup = dict(map(reversed, enumerate(states)))
    P = np.zeros((len(states), len(states)))
    for i, s in enumerate(states):
        a,b,c,d,e,f = s
        for f, p in enumerate(dice_weights):
            #j = index of state reached from state i when rolling face f
            j = i + base[f] * (s[f] < targets[f]) 
            j1 = lookup[s[:f] + (min(s[f]+1, targets[f]),) + s[f+1:]]
            if (j != j1):
                print(i, s, f, ' --> ' , j, j1)
            assert(j == j1)
            P[i,j] += p
    Q = P[:-1, :-1]
    I = np.identity(len(states)-1) 
    M = np.linalg.inv(I - Q)
    return M[0,:].sum()

print(get_expected_n_trials(targets, dice_weights))
# 61.28361802372382

Explanations of code:

• First we build the list of states using Cartesian product itertools.product
• For a given state i and die face f, we need to calculate j = state reached from i when adding f. I have two ways of calculating that, either as j = i + base[f] * (s[f] < targets[f]) or as j = lookup[s[:f] + (min(s[f]+1, targets[f]),) + s[f+1:]]. Because I’m paranoid, I calculated it both ways and checked that the two ways gave the same result. But you only need one way. You can remove lines j1 = ... to assert(j == j1) if you want.
• Matrix P begins filled with zeroes, and we fill up to six cells per row with P[i, j] += p where p is probability of rolling face f.
• Then we compute matrices Q and M as I indicated above.
• We return the sum of all the cells on the first row of M.

To help you better understand what is going on, I encourage you to examine the values of all variables. For instance you could replace return M[0, :].sum() with return states, base, lookup, P, Q, I, M and then write states, base, lookup, P, Q, I, M = get_expected_n_trials(targets, dice_weights) in the python interactive shell, so that you can look at the variables individually.