Парадокс Монти Холла: решение, объяснение простыми словами и симуляция

Что такое парадокс Монти Холла и какой у него ответ

Условие по шагам. Приз спрятан за одной из трёх дверей, за любой с равной вероятностью; в классической формулировке это автомобиль, а за двумя другими дверями козы. Вы выбираете дверь, допустим первую, но её пока не открывают. Ведущий знает, где приз, и открывает одну из двух других дверей — ту, за которой пусто; пусть это дверь 3. После этого он спрашивает, хотите ли вы поменять первую дверь на вторую.

Менять выгодно. Первая дверь выигрывает в одной игре из трёх, вторая — в двух из трёх. Логического противоречия в задаче нет, решение проверяется перебором за минуту. Парадоксом её называют из-за разрыва с интуицией, которая подсказывает «одна вторая».

При других правилах ведущего ответ другой — от нуля до единицы; об этом вторая половина статьи.

Как получить 2/3 перебором трёх раскладов

Самое короткое объяснение — перебрать, где может быть приз. Пусть вы выбрали дверь 1. Раскладов три, и они равновероятны: приз за первой, второй или третьей дверью.

Если приз за дверью 1, ведущий открывает любую из двух других, и смена ведёт к пустой двери. Если приз за дверью 2 или 3, выбора у ведущего нет: он открывает единственную пустую дверь, и закрытой остаётся дверь с призом.

Смена выигрывает в двух раскладах из трёх, сохранение — в одном. То же одной фразой: смена проигрывает, только когда вы угадали с первого раза, а это случается в трети игр.

Почему со ста дверями ответ виден сразу

Интуиции легче, когда дверей сто. Вы выбрали одну; вероятность, что приз за ней, — 1/100. Ведущий, зная расположение приза, открывает 98 пустых дверей и оставляет закрытыми вашу и ещё одну.

Чтобы приз оказался за вашей дверью, вы должны были угадать одну из ста. В остальных 99 случаях из 100 ведущий обходил приз и оставил закрытой именно его дверь. Смена выигрывает с вероятностью 99/100.

Три двери устроены так же, просто разница между 1/3 и 2/3 не так бросается в глаза. Оговорка прежняя: перекос создаёт знание ведущего. Если бы 98 дверей открывали наугад и приз по случайности не показался, две оставшиеся двери были бы равноправны — по 1/2.

Как решить задачу Монти Холла по формуле Байеса

Формула Байеса пересчитывает вероятность гипотезы после наблюдения; её устройство разобрано в отдельной статье. Гипотез три: приз за дверью 1, 2 или 3, априорная вероятность каждой — 1/3. Вы выбрали дверь 1 — это условие всех вероятностей ниже. Наблюдение: ведущий открыл дверь 3.

Главный шаг — записать, с какой вероятностью ведущий открыл бы именно дверь 3 при каждой гипотезе. Приз за дверью 1: ведущий выбирает между второй и третьей наугад, P(открыл 3 | приз за 1) = 1/2. Приз за дверью 2: третья — единственная, которую можно открыть, P(открыл 3 | приз за 2) = 1. Приз за дверью 3: её он не откроет, P(открыл 3 | приз за 3) = 0.

Полная вероятность наблюдения: P(открыл 3) = 1/3 × 1/2 + 1/3 × 1 + 1/3 × 0 = 1/2. Отсюда P(приз за 2 | открыл 3) = 1 × 1/3 / (1/2) = 2/3 и P(приз за 1 | открыл 3) = 1/2 × 1/3 / (1/2) = 1/3.

Ответ «50 на 50» получается, если не заметить разницу между 1/2 и 1 в этих условных вероятностях. Открытая третья дверь вдвое лучше согласуется с гипотезой «приз за второй», чем с гипотезой «приз за первой», и вероятности после наблюдения (апостериорные) делятся в той же пропорции — два к одному.

Как проверить ответ перебором в SQL и симуляцией на Python

Первый способ проверки — полный перебор: раскладов мало, случайные числа не нужны. Три положения приза, три выбора игрока и «монета» ведущего на случай, когда обе невыбранные двери пусты, дают 3 × 3 × 2 = 18 равновероятных игр. Номера дверей в сумме дают 6, поэтому дверь, на которую переходит игрок, — это 6 - pick - host_opens. Запрос не обращается к таблицам, одинаково работает в PostgreSQL и DuckDB и возвращает одну строку: 18 игр, сохранение выигрывает в 6, смена — в 12.

Второй способ — симуляция: скрипт разыгрывает 100 000 игр со случайным призом и случайным выбором игрока. Зерно генератора зафиксировано, поэтому результат воспроизводится.

Смена выиграла в 66,74% игр, сохранение — в 33,26%. От точных 2/3 результат отличается на 0,07 процентного пункта при стандартной ошибке доли (типичном случайном отклонении) 0,15 п. п. — расхождение в пределах шума.

Короткой серии для проверки не хватит. На десяти играх стандартная ошибка доли — около 15 п. п., и в 21% таких серий смена выигрывает не больше пяти раз из десяти. Чем длиннее серия, тем ближе доля к вероятности — это закон больших чисел.

WITH doors AS (
  SELECT d FROM generate_series(1, 3) AS g(d)
),
worlds AS (                 -- 3 × 3 × 2 = 18 равновероятных игр
  SELECT
    prize.d AS prize,       -- где приз
    pick.d AS pick,         -- что выбрал игрок
    coin.d AS coin,         -- монета ведущего: нужна, когда обе невыбранные двери пусты
    CASE WHEN pick.d = 1 THEN 2 ELSE 1 END AS low,    -- меньшая из двух невыбранных дверей
    CASE WHEN pick.d = 3 THEN 2 ELSE 3 END AS high    -- большая из них
  FROM doors AS prize
  CROSS JOIN doors AS pick
  CROSS JOIN generate_series(1, 2) AS coin(d)
),
opened AS (
  SELECT
    prize,
    pick,
    CASE
      WHEN prize = pick THEN CASE WHEN coin = 1 THEN low ELSE high END
      WHEN prize = low THEN high
      ELSE low
    END AS host_opens
  FROM worlds
)
SELECT
  COUNT(*) AS games,                                                                 -- 18
  SUM(CASE WHEN pick = prize THEN 1 ELSE 0 END) AS stay_wins,                        -- 6
  SUM(CASE WHEN 6 - pick - host_opens = prize THEN 1 ELSE 0 END) AS switch_wins,     -- 12
  ROUND(1.0 * SUM(CASE WHEN pick = prize THEN 1 ELSE 0 END) / COUNT(*), 4) AS p_stay,                    -- 0.3333
  ROUND(1.0 * SUM(CASE WHEN 6 - pick - host_opens = prize THEN 1 ELSE 0 END) / COUNT(*), 4) AS p_switch  -- 0.6667
FROM opened;

import numpy as np

rng = np.random.default_rng(2026)        # фиксированное зерно: результат воспроизводится
n = 100_000
prize = rng.integers(1, 4, n)            # где приз: дверь 1, 2 или 3
pick = rng.integers(1, 4, n)             # какую дверь выбрал игрок
coin = rng.integers(0, 2, n)             # монета ведущего на случай двух пустых дверей

low = np.where(pick == 1, 2, 1)          # меньшая из двух невыбранных дверей
high = np.where(pick == 3, 2, 3)         # большая из них
host_opens = np.where(
    prize == pick,
    np.where(coin == 0, low, high),      # игрок угадал: ведущий открывает любую из двух
    np.where(prize == low, high, low),   # не угадал: открывает единственную пустую
)
switch_to = 6 - pick - host_opens        # номера дверей в сумме дают 6

print(round((switch_to == prize).mean(), 4))   # 0.6674  смена
print(round((pick == prize).mean(), 4))        # 0.3326  сохранение

Почему ответ зависит от правила ведущего

Игрок видит одно и то же: открытая дверь, за ней пусто, предложение сменить выбор. Вероятность при этом зависит от правила, по которому дверь была открыта. Сравним трёх ведущих.

Первый — из условия задачи: знает, где приз, всегда открывает пустую дверь, а из двух пустых выбирает наугад. Поэтому открытая дверь о вашей ничего не сообщает: её шансы остаются 1/3, остальные 2/3 достаются второй закрытой.

Второй не знает, где приз, и открывает одну из двух невыбранных дверей наугад. В 6 играх из 18 он покажет приз, и предлагать будет нечего. В остальных 12 дверь оказалась пустой случайно, и смена выигрывает в 6 из них — в половине. У Джеффри Розенталя («Monty Hall, Monty Fall, Monty Crawl», Math Horizons, 2008) этот вариант назван Monty Fall, «Монти упал»: ведущий поскользнулся и нечаянно толкнул дверь. Пустая дверь здесь уже свидетельство: она гарантирована, когда приз за вашей дверью, и случается в половине случаев, когда он за другой. Шансы вашей двери растут с 1/3 до 1/2.

Третий открывает дверь и предлагает смену, только когда игрок угадал. Так бывает в 6 играх из 18, и смена проигрывает во всех шести. Игрок видит ту же картинку, что и в первых двух случаях.

Ради этого вывода задачу и стоит помнить: одинаковое наблюдение при разном механизме отбора даёт разные вероятности. Ответ «пополам» верен для второго ведущего; ошибка в том, что его переносят на первого.

WITH doors AS (
  SELECT d FROM generate_series(1, 3) AS g(d)
),
worlds AS (
  SELECT
    prize.d AS prize,
    pick.d AS pick,
    CASE WHEN pick.d = 1 THEN 2 ELSE 1 END AS low,
    CASE WHEN pick.d = 3 THEN 2 ELSE 3 END AS high,
    CASE                                              -- случайная из двух невыбранных дверей
      WHEN coin.d = 1 THEN CASE WHEN pick.d = 1 THEN 2 ELSE 1 END
      ELSE CASE WHEN pick.d = 3 THEN 2 ELSE 3 END
    END AS coin_door
  FROM doors AS prize
  CROSS JOIN doors AS pick
  CROSS JOIN generate_series(1, 2) AS coin(d)
),
rules AS (
  SELECT 1 AS rule_no, 'знает и открывает пустую' AS host_rule, prize, pick,
    CASE WHEN prize = pick THEN coin_door WHEN prize = low THEN high ELSE low END AS host_opens
  FROM worlds
  UNION ALL
  SELECT 2, 'открывает наугад', prize, pick, coin_door
  FROM worlds
  UNION ALL
  SELECT 3, 'открывает, только если игрок угадал', prize, pick,
    CASE WHEN prize = pick THEN coin_door END         -- иначе NULL: дверь не открыта
  FROM worlds
)
SELECT
  host_rule,
  COUNT(*) AS games,
  SUM(CASE WHEN host_opens <> prize THEN 1 ELSE 0 END) AS empty_shown,
  SUM(CASE WHEN host_opens <> prize AND pick = prize THEN 1 ELSE 0 END) AS stay_wins,
  SUM(CASE WHEN host_opens <> prize AND 6 - pick - host_opens = prize THEN 1 ELSE 0 END) AS switch_wins,
  ROUND(1.0 * SUM(CASE WHEN host_opens <> prize AND 6 - pick - host_opens = prize THEN 1 ELSE 0 END)
        / SUM(CASE WHEN host_opens <> prize THEN 1 ELSE 0 END), 4) AS p_switch
FROM rules
GROUP BY rule_no, host_rule
ORDER BY rule_no;
-- знает и открывает пустую:            18 / 18 / 6 / 12 / 0.6667
-- открывает наугад:                    18 / 12 / 6 / 6  / 0.5000
-- открывает, только если игрок угадал: 18 / 6  / 6 / 0  / 0.0000

import numpy as np

rng = np.random.default_rng(2026)
n = 100_000
prize = rng.integers(1, 4, n)
pick = rng.integers(1, 4, n)
coin = rng.integers(0, 2, n)
low = np.where(pick == 1, 2, 1)
high = np.where(pick == 3, 2, 3)
coin_door = np.where(coin == 0, low, high)   # случайная из двух невыбранных дверей

rules = {
    'знает и открывает пустую': np.where(prize == pick, coin_door, np.where(prize == low, high, low)),
    'открывает наугад': coin_door,
    'только если игрок угадал': np.where(prize == pick, coin_door, 0),   # 0 — дверь не открыта
}
for name, host_opens in rules.items():
    shown = (host_opens != 0) & (host_opens != prize)   # игрок видит пустую дверь и предложение
    switch = (6 - pick - host_opens == prize)[shown].mean()
    stay = (pick == prize)[shown].mean()
    print(f'{name}: предложений {shown.mean():.4f}, смена {switch:.4f}, сохранение {stay:.4f}')
# знает и открывает пустую: предложений 1.0000, смена 0.6674, сохранение 0.3326
# открывает наугад: предложений 0.6682, смена 0.5023, сохранение 0.4977
# только если игрок угадал: предложений 0.3326, смена 0.0000, сохранение 1.0000

При каких условиях ответ 2/3 верен

Ответ 2/3 опирается на пять условий — они собраны в списке в конце раздела. Первых четырёх хватает, чтобы стратегия «всегда менять» выигрывала в 2/3 игр. Пятое нужно, чтобы 2/3 получались в каждой игре, какую бы дверь ни открыл ведущий. В пересказах часть условий пропускают, и у задачи пропадает единственное решение.

Самое незаметное условие — про выбор между двумя пустыми дверями: ведущий открывает любую из них с равными шансами. Пусть ведущий ленив и из двух пустых дверей всегда открывает ту, что с меньшим номером; у Розенталя это Monty Crawl, «Монти ползёт». Вы выбрали дверь 1. Если он открыл третью, приз точно за второй: будь у него выбор, он открыл бы вторую. Если открыл вторую, у первой и третьей шансы равные, по 1/2. В среднем по всем играм смена по-прежнему выигрывает в 2/3 случаев, но в конкретной игре ответ уже зависит от того, какую дверь открыли. Менять при этом всё равно не хуже, чем оставаться: шансы смены не опускаются ниже 1/2.

• Приз спрятан случайно: за любой из трёх дверей с вероятностью 1/3.
• Ведущий обязан открыть одну из двух невыбранных дверей в каждой игре, а не когда ему удобно.
• Ведущий знает, где приз, и никогда не открывает дверь с призом.
• Ведущий всегда предлагает сменить выбор — и когда игрок угадал, и когда нет.
• Если обе невыбранные двери пусты, ведущий выбирает между ними случайно, с равными шансами.

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

Задача названа по имени Монти Холла, ведущего американской телеигры «Let's Make a Deal». В печати её в этом виде сформулировал Стив Селвин из Школы общественного здравоохранения Калифорнийского университета в Беркли: в феврале 1975 года журнал The American Statistician напечатал его письмо «A Problem in Probability». У Селвина вместо дверей три коробки, в одной ключи от автомобиля.

В августе вышло второе письмо, «On the Monty Hall Problem»: читатели спорили с ответом, и Селвин выписал допущение явно — ведущий знает, где ключи, а когда может открыть любую из двух коробок, выбирает наугад. Там же он цитирует письмо самого Монти Холла: когда одна коробка оказалась пустой, участник уже не может обменять свою, а его шансы остаются прежними — один из трёх.

Широкую известность задача получила в сентябре 1990 года, когда Мэрилин вос Савант разобрала её в колонке «Ask Marilyn» журнала Parade и посоветовала менять дверь. 21 июля 1991 года The New York Times вынесла спор на первую полосу (Джон Тирни, «Behind Monty Hall's Doors: Puzzle, Debate and Answer?»). По оценке самой вос Савант, пришло около 10 000 писем, в подавляющем большинстве от несогласных; почти тысяча критических была подписана людьми со степенью Ph.D.

В той же статье описан опыт дома у Монти Холла. За десять игр без смены журналист выиграл четыре раза, за десять со сменой — восемь. Потом Холл показал лазейку в формулировке: в ней не сказано, что ведущий обязан предлагать смену. Он стал предлагать её, только когда журналист угадывал, и выиграл восемь игр подряд — как третий ведущий из раздела о правилах. Мартин Гарднер там же назвал постановку некорректной, пока не оговорено, что ведущий всегда открывает пустую дверь и предлагает смену.

Что парадокс Монти Холла значит для работы с данными

Аналитик оказывается на месте игрока всякий раз, когда получает готовую выборку: список пользователей для опроса, выгрузку «активных», сегмент из чужого дашборда. Строки он видит, а правило, по которому они туда попали, — нет. Вывод зависит от этого правила так же, как шансы второй двери — от привычек ведущего.

Пример на учебной базе симулятора SQL-аналитика: 4 613 пользователей сервиса «Маяк», четыре канала привлечения. Вопрос: с какой вероятностью пользователь из списка пришёл из платного поиска (paid_search)? Запрос считает это для четырёх списков, а рядом — вероятность попасть в список для платного поиска и для остальных каналов.

Среди всех зарегистрированных доля платного поиска — 22,00%; столько же в среднем будет в случайной выборке. В списке сделавших экспорт отчёта — 13,06%: до экспорта дошли 12,71% пользователей платного поиска и 23,87% остальных. В списке оплативших — 9,43%. В списке зарегистрированных в июне — ноль: канал запустили 1 июля. Получив только список сделавших экспорт, вы увидели бы 13% платного поиска и не отличили бы «канал маленький» от «канал хуже доходит до экспорта» — как игрок по открытой двери не отличает первого ведущего от второго.

Механика та же, что у дверей: апостериорная вероятность пропорциональна априорной, умноженной на вероятность наблюдения при гипотезе. У дверей наблюдение — «ведущий открыл третью» с вероятностями 1/2, 1 и 0. Здесь наблюдение — «пользователь попал в список», и вероятности задаёт фильтр: 12,71% против 23,87%. В Python-блоке одна функция считает оба случая.

Оговорка про состав: платный поиск запущен 1 июля, остальные каналы работают с 1 июня. На регистрациях с 1 июля его доля — 28,4% среди зарегистрированных и 17,9% среди сделавших экспорт, так что сдвиг от фильтра остаётся. У списка оплативших поправка больше: первая оплата приходит через 3–20 дней, и поздние когорты не дозрели. На регистрациях 1 июля – 9 августа доля платного поиска среди оплативших — 14,14%, а не 9,43%; разбор — в статье о формуле Байеса. Перекос опроса дошедших до шага — в статье про ошибку выжившего.

WITH flags AS (
  SELECT
    CASE WHEN u.channel = 'paid_search' THEN 1 ELSE 0 END AS is_paid_search,
    CASE WHEN EXISTS (
      SELECT 1 FROM events e
      WHERE e.user_id = u.user_id AND e.event_name = 'export_completed'
    ) THEN 1 ELSE 0 END AS exported,
    CASE WHEN EXISTS (
      SELECT 1 FROM payments p WHERE p.user_id = u.user_id
    ) THEN 1 ELSE 0 END AS paid,
    CASE WHEN u.signup_date < DATE '2026-07-01' THEN 1 ELSE 0 END AS june
  FROM users u
),
lists AS (
  SELECT 1 AS list_no, 'все зарегистрированные' AS list_name, is_paid_search, 1 AS in_list FROM flags
  UNION ALL
  SELECT 2, 'сделали экспорт', is_paid_search, exported FROM flags
  UNION ALL
  SELECT 3, 'оплатили', is_paid_search, paid FROM flags
  UNION ALL
  SELECT 4, 'зарегистрировались в июне', is_paid_search, june FROM flags
)
SELECT
  list_name,
  SUM(in_list) AS list_size,
  SUM(in_list * is_paid_search) AS from_paid_search,
  ROUND(100.0 * SUM(in_list * is_paid_search) / SUM(is_paid_search), 2) AS p_list_if_paid_search,
  ROUND(100.0 * SUM(in_list * (1 - is_paid_search)) / SUM(1 - is_paid_search), 2) AS p_list_if_other,
  ROUND(100.0 * SUM(in_list * is_paid_search) / SUM(in_list), 2) AS paid_search_share
FROM lists
GROUP BY list_no, list_name
ORDER BY list_no;
-- все зарегистрированные:    4613 / 1015 / 100.00 / 100.00 / 22.00
-- сделали экспорт:            988 /  129 /  12.71 /  23.87 / 13.06
-- оплатили:                   912 /   86 /   8.47 /  22.96 /  9.43
-- зарегистрировались в июне: 1042 /    0 /   0.00 /  28.96 /  0.00

from fractions import Fraction as F

def posterior(prior, likelihood):
    joint = [p * l for p, l in zip(prior, likelihood)]   # априорная × вероятность наблюдения
    return [j / sum(joint) for j in joint]

doors = [F(1, 3)] * 3     # приз за дверью 1, 2, 3; игрок выбрал дверь 1, открыта дверь 3
print(*posterior(doors, [F(1, 2), 1, 0]))         # 1/3 2/3 0   знает и открывает пустую
print(*posterior(doors, [F(1, 2), F(1, 2), 0]))   # 1/2 1/2 0   открывает наугад
print(*posterior(doors, [F(1, 2), 0, 0]))         # 1 0 0       только если игрок угадал

# список сделавших экспорт: гипотезы «платный поиск» и «другой канал», счётчики из запроса выше
channels = [F(1015, 4613), F(4613 - 1015, 4613)]
in_list = [F(129, 1015), F(988 - 129, 4613 - 1015)]
print(round(float(posterior(channels, in_list)[0]) * 100, 2))   # 13.06

Где аналогия с дверями заканчивается

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

Различий больше. В учебной постановке правило ведущего задано условием и одно на все игры; в данных правило отбора обычно не записано, его восстанавливают по тексту запроса — по WHERE и JOIN. И ведущий действует намеренно, а фильтру знать ответ незачем: достаточно, чтобы попадание в выборку было статистически связано с тем, что вы измеряете.

Поэтому сдвигает ответ не каждый фильтр. Тот же список сделавших экспорт почти не искажает долю оплативших: среди них платили 20,85%, среди остальных — 19,48%. Разница 1,37 п. п. при 95%-м интервале ±2,84 п. п. от нуля неотличима. В учебной базе экспорт сильно связан с каналом и слабо — с оплатой; в настоящем продукте связь может оказаться любой. Один и тот же отбор безвреден для одного вопроса и портит другой, и проверяется это расчётом на полной совокупности.

Готового рецепта для запроса задача Монти Холла не даёт, зато приучает первым делом спрашивать, как получены строки.

Частые вопросы

Менять ли дверь в задаче Монти Холла? Да, если ведущий знает, где приз, обязан открыть пустую дверь и всегда предлагает смену: тогда смена выигрывает в 2/3 игр. Если правила ведущего неизвестны, единственного ответа у задачи нет.

Почему не 50 на 50, если осталось две двери? Двери неравноправны: свою вы выбрали вслепую, а вторую ведущий оставил закрытой, зная расположение приза. Равные шансы были бы, если бы он открывал дверь наугад.

Что изменится, если дверей четыре или больше? Если ведущий открывает все двери, кроме вашей и ещё одной, смена выигрывает с вероятностью (n − 1) / n: 3/4 для четырёх дверей, 99/100 для ста. Если из четырёх дверей он открывает только одну, у каждой из двух других закрытых дверей шансы 3/8 против 1/4 у вашей.

Что попробовать самому

Запросы из статьи можно выполнить в песочнице симулятора SQL-аналитика на той же учебной базе.

Первое упражнение — сделать ведущего ленивым. В запросе с перебором 18 игр замените выбор по монете, CASE WHEN coin = 1 THEN low ELSE high END, на low, пронесите столбец high в opened и сгруппируйте итог по условию host_opens = high. Должно получиться: большая из двух дверей открыта в 6 играх, и смена выигрывает во всех шести; меньшая — в 12 играх, смена выигрывает в 6.

Второе упражнение — в запросе о списках заменить paid_search на referral. Доля реферального канала среди всех зарегистрированных — 22,48%, в списке сделавших экспорт — 28,04%: фильтр, который занижал платный поиск, реферальный канал завышает.