Upload alea/gen_stoch.py with huggingface_hub

alea/gen_stoch.py

@@ -0,0 +1,647 @@
+"""Rich stochastic-event generators with exact closed-form ground truth.
+
+Calibration-critical module: every target is the exact conditional
+distribution, computed internally with fractions.Fraction and emitted as
+floats. Families: cards, bayesian_update, markov_chain, order_stats,
+conditional_joint, binomial_tail, first_success, coupon,
+multi_choice_stoch, and multi_probe (shared-state multi-question rows).
+"""
+
+import math
+import random
+from fractions import Fraction
+
+from alea.genbase import (generate, emit, q_choice, q_noul, q_score,
+                          validate_row, write_jsonl)
+
+rng = random.Random()
+
+SUITS = ("hearts", "diamonds", "clubs", "spades")
+SUIT_SG = {"hearts": "heart", "diamonds": "diamond",
+           "clubs": "club", "spades": "spade"}
+COLORS = ["red", "blue", "green", "black", "white", "amber", "violet", "gray"]
+FIRST = ["Mara", "Tobias", "Priya", "Kenji", "Lucia", "Omar", "Ingrid",
+         "Felix", "Sofia", "Dmitri", "Amara", "Jonas", "Nadia", "Pablo"]
+RANKS = ["ace", "2", "3", "4", "5", "6", "7", "8", "9", "10",
+         "jack", "queen", "king"]
+
+
+def _p_str(p):
+    """Render an exact per-trial probability unambiguously in state text."""
+    if (p * 100).denominator == 1:
+        return f"probability {float(p):.2f}"
+    return f"probability {p.numerator} in {p.denominator}"
+
+
+# ---------- cards ----------
+
+_ONE_DRAW = [
+    "A standard deck of 52 playing cards is shuffled thoroughly and one "
+    "card is drawn uniformly at random.",
+    "From a well-shuffled standard 52-card deck, a dealer draws a single "
+    "card at random.",
+    "A spectator picks one card at random from a freshly shuffled "
+    "standard deck of 52 cards.",
+]
+
+_TWO_DRAW = [
+    "A standard deck of 52 playing cards is shuffled thoroughly. Two "
+    "cards are drawn one at a time without replacement.",
+    "From a well-shuffled standard 52-card deck, a dealer deals two "
+    "cards in sequence without replacement.",
+    "Two cards are drawn at random, one after the other and without "
+    "replacement, from a standard 52-card deck.",
+]
+
+
+def gen_cards():
+    if rng.random() < 0.4:
+        state = rng.choice(_TWO_DRAW)
+        kind = rng.choice(["pair", "same_suit", "both_suit",
+                           "at_least_ace", "both_face", "ace_count",
+                           "color_cmp"])
+        if kind == "pair":
+            # whatever the first card is, 3 of the remaining 51 match its rank
+            q = q_noul("pair", "Will the two cards have the same rank "
+                       "(a pair)?", Fraction(3, 51))
+        elif kind == "same_suit":
+            q = q_noul("suit", "Will both cards be of the same suit?",
+                       Fraction(12, 51))
+        elif kind == "both_suit":
+            s = rng.choice(SUITS)
+            q = q_noul("suit", f"Will both cards be {s}?",
+                       Fraction(13, 52) * Fraction(12, 51))
+        elif kind == "at_least_ace":
+            p = 1 - Fraction(48, 52) * Fraction(47, 51)
+            q = q_noul("ace", "Will at least one of the two cards be an "
+                       "ace?", p)
+        elif kind == "both_face":
+            q = q_noul("face", "Will both cards be face cards (jack, "
+                       "queen or king)?",
+                       Fraction(12, 52) * Fraction(11, 51))
+        elif kind == "ace_count":
+            denom = 52 * 51
+            dist = [float(Fraction(48 * 47, denom)),
+                    float(Fraction(2 * 4 * 48, denom)),
+                    float(Fraction(4 * 3, denom))]
+            q = q_choice("aces", "How many of the two cards are aces?",
+                         ["Neither card is an ace.",
+                          "Exactly one card is an ace.",
+                          "Both cards are aces."], dist)
+        else:
+            same_c = Fraction(26 * 25, 52 * 51)
+            dist = [float(same_c), float(same_c),
+                    float(1 - 2 * same_c)]
+            q = q_choice("colors", "How do the two cards compare in "
+                         "color?", ["Both cards are red.",
+                                    "Both cards are black.",
+                                    "The cards are different colors."],
+                         dist)
+        return state, [q]
+
+    state = rng.choice(_ONE_DRAW)
+    kind = rng.choice(["suit", "face", "ace", "specific", "red",
+                       "color_choice", "suit_choice", "rank_choice"])
+    if kind == "suit":
+        s = rng.choice(SUITS)
+        q = q_noul("card", f"Is the drawn card a {SUIT_SG[s]}?",
+                   Fraction(1, 4))
+    elif kind == "face":
+        q = q_noul("card", "Is the drawn card a face card (jack, queen "
+                   "or king)?", Fraction(12, 52))
+    elif kind == "ace":
+        q = q_noul("card", "Is the drawn card an ace?", Fraction(4, 52))
+    elif kind == "specific":
+        q = q_noul("card", f"Is the drawn card the {rng.choice(RANKS)} "
+                   f"of {rng.choice(SUITS)}?", Fraction(1, 52))
+    elif kind == "red":
+        q = q_noul("card", "Is the drawn card red (hearts or diamonds)?",
+                   Fraction(1, 2))
+    elif kind == "color_choice":
+        q = q_choice("card", "What color is the drawn card?",
+                     ["The card is red (hearts or diamonds).",
+                      "The card is black (clubs or spades)."],
+                     [0.5, 0.5])
+    elif kind == "suit_choice":
+        q = q_choice("card", "Which suit is the drawn card?",
+                     [f"The card is a {SUIT_SG[s]}." for s in SUITS],
+                     [0.25] * 4)
+    else:
+        q = q_choice("card", "What kind of card is drawn?",
+                     ["The card is an ace.",
+                      "The card is a face card (jack, queen or king).",
+                      "The card is a number card (2 through 10)."],
+                     [float(Fraction(4, 52)), float(Fraction(12, 52)),
+                      float(Fraction(36, 52))])
+    return state, [q]
+
+
+# ---------- bayesian_update ----------
+
+def _posterior(prev, sens, spec):
+    """Exact P(condition | positive); args are integer percents."""
+    pv, se, sp = (Fraction(prev, 100), Fraction(sens, 100),
+                  Fraction(spec, 100))
+    num = se * pv
+    return num / (num + (1 - sp) * (1 - pv))
+
+
+def gen_bayesian_update():
+    scen = rng.choice(["medical", "spam", "defect", "fraud"])
+    if scen == "medical":
+        prev = rng.choice([1, 2, 5, 10])
+    elif scen == "fraud":
+        prev = rng.choice([1, 2, 5])
+    else:
+        prev = rng.choice([2, 5, 10, 20, 40])
+    sens = rng.choice([80, 85, 90, 95, 99])
+    spec = rng.choice([80, 90, 95, 98, 99])
+    post = _posterior(prev, sens, spec)
+    if scen == "medical":
+        cond = rng.choice(["a rare infection", "the condition",
+                           "a viral disease"])
+        state = (f"A screening test for {cond} is given to the general "
+                 f"population, where the prevalence is {prev}%. The test "
+                 f"has sensitivity {sens}% (it detects {sens}% of true "
+                 f"cases) and specificity {spec}% (it falsely flags "
+                 f"{100 - spec}% of healthy people). "
+                 f"{rng.choice(FIRST)} tests positive.")
+        pos = "The person has the condition."
+        neg = "The person does not have the condition."
+        instr = "Given the positive test, does the person have the condition?"
+    elif scen == "spam":
+        state = (f"An email filter flags spam. {prev}% of incoming mail "
+                 f"is spam. The filter catches {sens}% of spam messages "
+                 f"and falsely flags {100 - spec}% of legitimate mail. "
+                 f"A message has just been flagged as spam.")
+        pos = "The message is spam."
+        neg = "The message is legitimate."
+        instr = "Is the flagged message actually spam?"
+    elif scen == "defect":
+        state = (f"A vision system inspects parts on an assembly line. "
+                 f"{prev}% of parts have a defect. The system detects "
+                 f"{sens}% of defective parts and raises false alarms "
+                 f"on {100 - spec}% of good parts. A part has just been "
+                 f"flagged.")
+        pos = "The part is defective."
+        neg = "The part is good."
+        instr = "Is the flagged part actually defective?"
+    else:
+        state = (f"A fraud detector monitors card transactions. {prev}% "
+                 f"of all transactions are fraudulent. The detector "
+                 f"catches {sens}% of fraudulent transactions but also "
+                 f"flags {100 - spec}% of legitimate ones. A transaction "
+                 f"has just been flagged.")
+        pos = "The transaction is fraudulent."
+        neg = "The transaction is legitimate."
+        instr = "Is the flagged transaction actually fraudulent?"
+    if rng.random() < 0.5:
+        return state, [q_noul("post", instr, post)]
+    pair = [(pos, post), (neg, 1 - post)]
+    if rng.random() < 0.5:
+        pair.reverse()
+    return state, [q_choice("post", "Which is the case?",
+                            [t for t, _ in pair],
+                            [float(p) for _, p in pair])]
+
+
+# ---------- markov_chain ----------
+
+def gen_markov_chain():
+    a = rng.choice([50, 60, 70, 80, 90])   # P(A -> A), percent
+    b = rng.choice([20, 30, 40, 50, 60])   # P(B -> A), percent
+    k = rng.choice([2, 3, 4])
+    start = rng.choice([0, 1])
+    scen = rng.choice(["weather", "server", "plant", "commute"])
+    if scen == "weather":
+        A, B, unit = "sunny", "rainy", "day"
+        state = (f"Weather follows a two-state pattern: a sunny day is "
+                 f"followed by another sunny day with probability {a}%, "
+                 f"and a rainy day is followed by a sunny day with "
+                 f"probability {b}%. Today (day 0) is "
+                 f"{'sunny' if start == 0 else 'rainy'}.")
+        instr = f"Will it be sunny on day {k}?"
+    elif scen == "server":
+        A, B, unit = "up", "down", "day"
+        state = (f"A server is either 'up' or 'down' each day. An up "
+                 f"day is followed by another up day with probability "
+                 f"{a}%; a down day is followed by an up day with "
+                 f"probability {b}%. Today (day 0) the server is "
+                 f"{'up' if start == 0 else 'down'}.")
+        instr = f"Will the server be up on day {k}?"
+    elif scen == "plant":
+        A, B, unit = "healthy", "wilted", "day"
+        state = (f"A greenhouse plant is either healthy or wilted each "
+                 f"morning. A healthy morning is followed by another "
+                 f"healthy morning with probability {a}%; a wilted "
+                 f"morning is followed by a healthy morning with "
+                 f"probability {b}%. This morning (day 0) the plant is "
+                 f"{'healthy' if start == 0 else 'wilted'}.")
+        instr = f"Will the plant be healthy on day {k}?"
+    else:
+        A, B, unit = "on time", "delayed", "morning"
+        state = (f"{rng.choice(FIRST)}'s commute is either on time or "
+                 f"delayed each morning. An on-time morning is followed "
+                 f"by another on-time morning with probability {a}%; a "
+                 f"delayed morning is followed by an on-time morning "
+                 f"with probability {b}%. This morning (morning 0) the "
+                 f"commute was {'on time' if start == 0 else 'delayed'}.")
+        instr = f"Will the commute be on time on morning {k}?"
+    pa, pb = Fraction(a, 100), Fraction(b, 100)
+    d = [Fraction(1), Fraction(0)] if start == 0 else [Fraction(0), Fraction(1)]
+    for _ in range(k):
+        d = [d[0] * pa + d[1] * pb, d[0] * (1 - pa) + d[1] * (1 - pb)]
+    if rng.random() < 0.5:
+        return state, [q_noul("mk", instr, d[0])]
+    return state, [q_choice("mk", f"What will the state be on {unit} {k}?",
+                            [f"It is {A}.", f"It is {B}."],
+                            [float(d[0]), float(d[1])])]
+
+
+# ---------- order_stats ----------
+
+def gen_order_stats():
+    n = rng.randint(2, 5)
+    s = rng.choice([4, 6, 8, 10, 12, 20])
+    state = rng.choice([
+        f"{n} fair {s}-sided dice are rolled.",
+        f"A player rolls {n} identical {s}-sided dice.",
+        f"{n} fair dice with {s} faces each are tossed together.",
+    ])
+    kinds = ["max_eq", "min_ge", "atleast_gt", "max_le"]
+    if s <= 8:
+        kinds += ["score_max", "score_max"]
+    kind = rng.choice(kinds)
+    if kind == "max_eq":
+        k = rng.randint(1, s)
+        p = Fraction(k ** n - (k - 1) ** n, s ** n)
+        q = q_noul("max", f"Will the highest die show exactly {k}?", p)
+    elif kind == "min_ge":
+        t = rng.randint(2, s)
+        p = Fraction((s - t + 1) ** n, s ** n)
+        q = q_noul("min", f"Will every die show {t} or more?", p)
+    elif kind == "atleast_gt":
+        t = rng.randint(1, s - 1)
+        p = 1 - Fraction(t ** n, s ** n)
+        q = q_noul("any", f"Will at least one die show more than {t}?", p)
+    elif kind == "max_le":
+        t = rng.randint(2, s)
+        p = Fraction(t ** n, s ** n)
+        q = q_noul("max", f"Will the highest die show {t} or less?", p)
+    else:
+        levels = [f"The highest die shows {k}." for k in range(1, s + 1)]
+        dist = [float(Fraction(k ** n - (k - 1) ** n, s ** n))
+                for k in range(1, s + 1)]
+        q = q_score("max", "What will the highest single die show?",
+                    levels, dist)
+    return state, [q]
+
+
+# ---------- conditional_joint ----------
+
+_JOINT_SCEN = [
+    dict(rows=["Line 1", "Line 2", "Line 3"], cols=["pass", "fail"],
+         noun="parts", sing="part", col_word="result",
+         intro="A factory quality log records", row_noun="line"),
+    dict(rows=["treatment A", "treatment B"], cols=["recovered", "unchanged"],
+         noun="patients", sing="patient", col_word="outcome",
+         intro="A clinic tracked", row_noun="treatment group"),
+    dict(rows=["engineering", "sales", "support"], cols=["remote", "on-site"],
+         noun="employees", sing="employee", col_word="location",
+         intro="An HR survey of", row_noun="department"),
+]
+
+
+def gen_conditional_joint():
+    sc = rng.choice(_JOINT_SCEN)
+    rows_l, cols_l = sc["rows"], sc["cols"]
+    cells = {(i, j): rng.randint(5, 50)
+             for i in range(len(rows_l)) for j in range(len(cols_l))}
+    total = sum(cells.values())
+    parts = "; ".join(
+        f"{rows_l[i]}: " + ", ".join(
+            f"{cells[(i, j)]} {cols_l[j]}" for j in range(len(cols_l)))
+        for i in range(len(rows_l)))
+    state = (f"{sc['intro']} {total} {sc['noun']}: {parts}. One "
+             f"{sc['sing']} is chosen uniformly at random from the "
+             f"{total}.")
+    mode = rng.choice(["row_noul", "col_noul", "row_choice",
+                       "col_choice"])
+    if mode == "row_noul":
+        i = rng.randrange(len(rows_l))
+        j = rng.randrange(len(cols_l))
+        rs = sum(cells[(i, jj)] for jj in range(len(cols_l)))
+        q = q_noul("cond", f"Given the {sc['sing']} is from {rows_l[i]}, "
+                   f"is its {sc['col_word']} '{cols_l[j]}'?",
+                   Fraction(cells[(i, j)], rs))
+    elif mode == "col_noul":
+        j = rng.randrange(len(cols_l))
+        i = rng.randrange(len(rows_l))
+        cs = sum(cells[(ii, j)] for ii in range(len(rows_l)))
+        q = q_noul("cond", f"Given the {sc['sing']}'s {sc['col_word']} "
+                   f"is '{cols_l[j]}', is it from {rows_l[i]}?",
+                   Fraction(cells[(i, j)], cs))
+    elif mode == "row_choice":
+        i = rng.randrange(len(rows_l))
+        rs = sum(cells[(i, jj)] for jj in range(len(cols_l)))
+        dist = [float(Fraction(cells[(i, jj)], rs))
+                for jj in range(len(cols_l))]
+        q = q_choice("cond",
+                     f"The {sc['sing']} is from {rows_l[i]}. What is "
+                     f"its {sc['col_word']}?",
+                     [f"Its {sc['col_word']} is '{c}'." for c in cols_l],
+                     dist)
+    else:
+        j = rng.randrange(len(cols_l))
+        cs = sum(cells[(ii, j)] for ii in range(len(rows_l)))
+        dist = [float(Fraction(cells[(ii, j)], cs))
+                for ii in range(len(rows_l))]
+        q = q_choice("cond",
+                     f"The {sc['sing']}'s {sc['col_word']} is "
+                     f"'{cols_l[j]}'. Which {sc['row_noun']} is it from?",
+                     [f"It is from {r}." for r in rows_l], dist)
+    return state, [q]
+
+
+# ---------- binomial_tail ----------
+
+def _binom_tail(n, p, k):
+    return sum(math.comb(n, i) * p ** i * (1 - p) ** (n - i)
+               for i in range(k, n + 1))
+
+
+def gen_binomial_tail():
+    scen = rng.choice(["freethrow", "defect", "quiz", "packet"])
+    if scen == "freethrow":
+        p = rng.choice([Fraction(1, 2), Fraction(3, 5),
+                        Fraction(7, 10), Fraction(4, 5)])
+        n = rng.randint(6, 10)
+        k = rng.randint(max(2, n - 4), n)
+        nm = rng.choice(FIRST)
+        state = (f"{nm} is a basketball player who makes each free "
+                 f"throw with {_p_str(p)}, independently. {nm} takes "
+                 f"{n} free throws.")
+        instr = f"Will {nm} make at least {k} of the {n} free throws?"
+        stem = f"How many of the {n} free throws go in?"
+    elif scen == "defect":
+        p = rng.choice([Fraction(1, 20), Fraction(1, 10), Fraction(1, 5)])
+        n = rng.randint(8, 15)
+        k = rng.randint(1, 3)
+        state = (f"A machine produces a defective part with {_p_str(p)} "
+                 f"each cycle, independently. A batch of {n} parts is "
+                 f"inspected.")
+        instr = (f"Will the batch contain at least {k} defective "
+                 f"part{'s' if k > 1 else ''}?")
+        stem = "How many defective parts does the batch contain?"
+    elif scen == "quiz":
+        p = Fraction(1, 4)
+        n = rng.randint(5, 8)
+        k = rng.randint(2, n - 1)
+        state = (f"A quiz has {n} multiple-choice questions with 4 "
+                 f"options each. {rng.choice(FIRST)} guesses uniformly "
+                 f"at random on every question.")
+        instr = f"Will they get at least {k} of the {n} questions right?"
+        stem = "How many questions do they get right?"
+    else:
+        p = rng.choice([Fraction(9, 10), Fraction(19, 20)])
+        n = rng.randint(4, 8)
+        k = rng.randint(n - 2, n)
+        state = (f"Each data packet sent over a link arrives with "
+                 f"{_p_str(p)}, independently of the others. {n} "
+                 f"packets are sent.")
+        instr = f"Will at least {k} of the {n} packets arrive?"
+        stem = f"How many of the {n} packets arrive?"
+    tail = _binom_tail(n, p, k)
+    if rng.random() < 0.45:
+        return state, [q_choice("tail", stem,
+                                [f"At least {k}.", f"Fewer than {k}."],
+                                [float(tail), float(1 - tail)])]
+    return state, [q_noul("tail", instr, tail)]
+
+
+# ---------- first_success ----------
+
+def gen_first_success():
+    scen = rng.choice(["bullseye", "sale", "defect", "crash", "hire"])
+    p = rng.choice([Fraction(1, 10), Fraction(1, 6), Fraction(1, 5),
+                    Fraction(1, 4), Fraction(3, 10), Fraction(2, 5),
+                    Fraction(1, 2)])
+    k = rng.randint(2, 8)
+    p_first = 1 - (1 - p) ** k
+    if scen == "bullseye":
+        state = (f"{rng.choice(FIRST)} throws darts; each throw hits "
+                 f"the bullseye with {_p_str(p)}, independently. They "
+                 f"throw {k} darts.")
+        instr = f"Will at least one of the {k} darts hit the bullseye?"
+    elif scen == "sale":
+        state = (f"A salesperson closes each call with {_p_str(p)}, "
+                 f"independently. They make {k} calls today.")
+        instr = f"Will they close at least one sale within the {k} calls?"
+    elif scen == "defect":
+        state = (f"Each item on a line is defective with {_p_str(p)}, "
+                 f"independently. {k} items are checked in sequence.")
+        instr = (f"Will a defective item appear within the {k} checked "
+                 f"items?")
+    elif scen == "crash":
+        state = (f"A flaky test crashes on each run with {_p_str(p)}, "
+                 f"independently. The test is run {k} times.")
+        instr = f"Will the test crash at least once in the {k} runs?"
+    else:
+        state = (f"Each interviewed candidate accepts the job offer "
+                 f"with {_p_str(p)}, independently. {k} candidates are "
+                 f"interviewed.")
+        instr = f"Will at least one of the {k} candidates accept?"
+    if rng.random() < 0.4:
+        return state, [q_choice("first",
+                                "What happens across the trials?",
+                                [f"A success occurs within the {k} "
+                                 f"trials.",
+                                 f"No success occurs in the {k} "
+                                 f"trials."],
+                                [float(p_first), float(1 - p_first)])]
+    return state, [q_noul("first", instr, p_first)]
+
+
+# ---------- coupon ----------
+
+def gen_coupon():
+    scen = rng.choice(["cereal", "sticker", "loot", "vending"])
+    m = rng.randint(3, 5)
+    n = rng.randint(m, m + 8)
+    t0 = rng.randint(1, m)
+    if scen == "cereal":
+        state = (f"Each box of cereal contains one of {m} prize types, "
+                 f"each type equally likely. {rng.choice(FIRST)} buys "
+                 f"{n} boxes.")
+        unit = "boxes"
+    elif scen == "sticker":
+        state = (f"Each sticker pack contains one of {m} sticker "
+                 f"designs, each design equally likely. "
+                 f"{rng.choice(FIRST)} buys {n} packs.")
+        unit = "packs"
+    elif scen == "loot":
+        state = (f"A game loot box drops one of {m} item types, each "
+                 f"equally likely. A player opens {n} loot boxes.")
+        unit = "loot boxes"
+    else:
+        state = (f"A vending machine dispenses one of {m} toy types at "
+                 f"random, each equally likely. A child gets {n} toys.")
+        unit = "toys"
+    kind = rng.choice(["all", "specific", "missing"])
+    if kind == "all":
+        # inclusion-exclusion over the m types
+        p = sum(Fraction((-1) ** j) * math.comb(m, j) * (m - j) ** n
+                for j in range(m)) / m ** n
+        instr = f"Will they collect all {m} types in the {n} {unit}?"
+        if rng.random() < 0.45:
+            return state, [q_choice(
+                "coupon", "What does the collection look like after the "
+                f"{n} {unit}?",
+                [f"All {m} types were collected.",
+                 "At least one type is still missing."],
+                [float(p), float(1 - p)])]
+    elif kind == "specific":
+        p = 1 - Fraction((m - 1) ** n, m ** n)
+        instr = (f"Will at least one of the {n} {unit} contain type "
+                 f"{t0}?")
+        if rng.random() < 0.45:
+            return state, [q_choice(
+                "coupon", f"What happens with type {t0} across the {n} "
+                f"{unit}?",
+                [f"Type {t0} appears at least once.",
+                 f"Type {t0} never appears."],
+                [float(p), float(1 - p)])]
+    else:
+        p = Fraction((m - 1) ** n, m ** n)
+        instr = f"Will type {t0} still be missing after the {n} {unit}?"
+    return state, [q_noul("coupon", instr, p)]
+
+
+# ---------- multi_choice_stoch ----------
+
+def gen_multi_choice_stoch():
+    variant = rng.choice(["dice_buckets", "two_cards", "coins", "wheel"])
+    if variant == "dice_buckets":
+        s1, s2 = rng.choice([(6, 6), (8, 8), (6, 4), (4, 4), (10, 10)])
+        counts = {}
+        for a_ in range(1, s1 + 1):
+            for b_ in range(1, s2 + 1):
+                counts[a_ + b_] = counts.get(a_ + b_, 0) + 1
+        total = s1 * s2
+        lo, hi = min(counts), max(counts)
+        nb = rng.choice([3, 4])
+        cuts = sorted(rng.sample(range(lo + 1, hi), nb - 1))
+        edges = [lo - 1] + cuts + [hi]
+        opts, dist = [], []
+        for e_lo, e_hi in zip(edges[:-1], edges[1:]):
+            c = sum(v for s_, v in counts.items() if e_lo < s_ <= e_hi)
+            label = (f"The total is {e_lo + 1}" if e_lo + 1 == e_hi
+                     else f"The total is {e_lo + 1} to {e_hi}")
+            opts.append(label + ".")
+            dist.append(float(Fraction(c, total)))
+        state = rng.choice([
+            f"Two fair dice are rolled: one {s1}-sided and one "
+            f"{s2}-sided. Their results are added.",
+            f"A {s1}-sided die and a {s2}-sided die, both fair, are "
+            f"rolled and summed.",
+        ])
+        q = q_choice("sum", "Into which range does the total fall?",
+                     opts, dist)
+    elif variant == "two_cards":
+        state = rng.choice(_TWO_DRAW)
+        same_color = Fraction(26 * 25, 52 * 51)
+        mixed = 1 - 2 * same_color
+        q = q_choice("colors", "How do the two cards compare in color?",
+                     ["Both cards are red.", "Both cards are black.",
+                      "The cards are different colors."],
+                     [float(same_color), float(same_color), float(mixed)])
+    elif variant == "coins":
+        n = rng.choice([3, 4, 5])
+        state = rng.choice([
+            f"{n} fair coins are flipped at once.",
+            f"{rng.choice(FIRST)} flips {n} fair coins.",
+        ])
+        opts = [f"Exactly {k} coin{'s' if k != 1 else ''} land "
+                f"{'heads' if k != 1 else 'heads'}." for k in range(n + 1)]
+        dist = [float(Fraction(math.comb(n, k), 2 ** n))
+                for k in range(n + 1)]
+        q = q_choice("heads", "How many coins land heads?", opts, dist)
+    else:
+        cols = rng.sample(COLORS, 3)
+        segs = [rng.randint(1, 6) for _ in cols]
+        tot = sum(segs)
+        state = (f"A spinner is divided into {tot} equal sectors: " +
+                 ", ".join(f"{s_} {c}" for s_, c in zip(segs, cols)) +
+                 ". It is spun once.")
+        q = q_choice("spin", "Which color does the spinner land on?",
+                     [f"The spinner lands on {c}." for c in cols],
+                     [s_ / tot for s_ in segs])
+    return state, [q]
+
+
+# ---------- multi_probe (shared-state multi-question) ----------
+
+def gen_multi_probe():
+    cols = rng.sample(COLORS, rng.choice([2, 3]))
+    counts = {c: rng.randint(2, 9) for c in cols}
+    total = sum(counts.values())
+    listing = ", ".join(f"{counts[c]} {c}" for c in cols)
+    rep = rng.random() < 0.3
+    how = "with" if rep else "without"
+    state = (f"An urn contains {listing} balls ({total} total). Two "
+             f"balls are drawn one at a time {how} replacement.")
+    c0 = rng.choice(cols)
+    qs = [q_noul("first", f"Is the first ball drawn {c0}?",
+                 Fraction(counts[c0], total))]
+    if rep:
+        p_same = sum(Fraction(v * v) for v in counts.values()) \
+            / (total * total)
+    else:
+        p_same = sum(Fraction(v * (v - 1)) for v in counts.values()) \
+            / (total * (total - 1))
+    qs.append(q_noul("same", "Are both drawn balls the same color?",
+                     p_same))
+    if rng.random() < 0.75:
+        if rep:
+            dist = [float(Fraction(counts[c], total)) for c in cols]
+        else:
+            dist = [float(Fraction(counts[c] - (1 if c == c0 else 0),
+                                   total - 1)) for c in cols]
+        qs.append(q_choice(
+            "second",
+            f"The first ball is {c0}. Which color is the second ball?",
+            [f"The second ball is {c}." for c in cols], dist))
+    return state, qs
+
+
+FAMILIES = {
+    "cards": gen_cards,
+    "bayesian_update": gen_bayesian_update,
+    "markov_chain": gen_markov_chain,
+    "order_stats": gen_order_stats,
+    "conditional_joint": gen_conditional_joint,
+    "binomial_tail": gen_binomial_tail,
+    "first_success": gen_first_success,
+    "coupon": gen_coupon,
+    "multi_choice_stoch": gen_multi_choice_stoch,
+    "multi_probe": gen_multi_probe,
+}
+
+WEIGHTS = {
+    "cards": 0.12, "bayesian_update": 0.12, "markov_chain": 0.10,
+    "order_stats": 0.10, "conditional_joint": 0.10,
+    "binomial_tail": 0.12, "first_success": 0.08, "coupon": 0.08,
+    "multi_choice_stoch": 0.10, "multi_probe": 0.08,
+}
+
+
+def make_rows(n, seed):
+    return generate(FAMILIES, WEIGHTS, n, seed, rng)
+
+
+if __name__ == "__main__":
+    rows = make_rows(10, 0)
+    for r in rows[:3]:
+        validate_row(r)
+        print(r["id"], "|", r["state"][:100])
+    print(f"{len(rows)} rows OK")