| """Synthetic System One task generator.
|
|
|
| Every item is one request: {state, questions{qid: {...}}}, plus targets
|
| {qid: {key: q}}. For stochastic event families, q is the exact conditional
|
| distribution computed in closed form — that is what lets us measure
|
| known-q L2 and real calibration, not just accuracy.
|
| """
|
| import json
|
| import math
|
| import random
|
| from fractions import Fraction
|
|
|
| rng = random.Random()
|
|
|
| COLORS = ["red", "blue", "green", "black", "white", "amber", "violet", "gray"]
|
| FIRST = ["Mara", "Tobias", "Priya", "Kenji", "Lucia", "Omar", "Ingrid", "Felix",
|
| "Sofia", "Dmitri", "Amara", "Jonas", "Nadia", "Pablo", "Yuki", "Elena"]
|
| PRODUCTS = ["a headset", "a coffee grinder", "a keyboard", "a standing lamp",
|
| "a backpack", "a monitor arm", "a water bottle", "a desk mat"]
|
| ISSUES = ["a billing error", "a login failure", "a shipping delay",
|
| "a damaged item", "a feature request", "an account lockout"]
|
| PLANS = ["free", "starter", "pro", "enterprise"]
|
| COUNTRIES = ["US", "DE", "FR", "JP", "BR", "IN", "GB", "CA", "AU", "SE"]
|
| EU = {"DE", "FR", "SE"}
|
|
|
|
|
| def _q_choice(qid, instructions, options, q):
|
| """options: list[str] option texts; q: list[float] aligned."""
|
| return {"qid": qid, "qtype": "choice", "instructions": instructions,
|
| "options": options, "target": q}
|
|
|
|
|
| def _q_noul(qid, instructions, q):
|
| return {"qid": qid, "qtype": "noul", "instructions": instructions,
|
| "options": [], "target": q}
|
|
|
|
|
| def _q_score(qid, instructions, levels, q):
|
| return {"qid": qid, "qtype": "score", "instructions": instructions,
|
| "options": levels, "target": q}
|
|
|
|
|
|
|
|
|
| def gen_urn():
|
| n_colors = rng.randint(2, 4)
|
| colors = rng.sample(COLORS, n_colors)
|
| counts = {c: rng.randint(1, 12) for c in colors}
|
| total = sum(counts.values())
|
| balls = ", ".join(f"{counts[c]} {c}" for c in colors)
|
| state = (f"An urn contains {balls} ball{'s' if total > 1 else ''} "
|
| f"({total} total). One ball is drawn uniformly at random.")
|
| if rng.random() < 0.5:
|
| c = rng.choice(colors)
|
| q = _q_noul("draw", f"Will the drawn ball be {c}?", counts[c] / total)
|
| else:
|
| opts = [f"The drawn ball is {c}." for c in colors]
|
| q = _q_choice("draw", "Which color is drawn?", opts,
|
| [counts[c] / total for c in colors])
|
| return state, [q]
|
|
|
|
|
| def gen_two_draws():
|
| c1, c2 = rng.sample(COLORS, 2)
|
| r, b = rng.randint(2, 10), rng.randint(2, 10)
|
| total = r + b
|
| rep = rng.random() < 0.5
|
| state = (f"An urn contains {r} {c1} and {b} {c2} balls. Two balls are "
|
| f"drawn one at a time, {'with' if rep else 'without'} replacement.")
|
| kind = rng.choice(["both", "same", "atleast"])
|
| if kind == "both":
|
| p = (r / total) * ((r / total) if rep else (r - 1) / (total - 1))
|
| q = _q_noul("two", f"Will both drawn balls be {c1}?", p)
|
| elif kind == "same":
|
| if rep:
|
| p = (r / total) ** 2 + (b / total) ** 2
|
| else:
|
| p = r * (r - 1) / (total * (total - 1)) + \
|
| b * (b - 1) / (total * (total - 1))
|
| q = _q_noul("two", "Will both drawn balls be the same color?", p)
|
| else:
|
| if rep:
|
| p = 1 - (b / total) ** 2
|
| else:
|
| p = 1 - b * (b - 1) / (total * (total - 1))
|
| q = _q_noul("two", f"Will at least one drawn ball be {c1}?", p)
|
| return state, [q]
|
|
|
|
|
| def gen_dice():
|
| n = rng.randint(1, 4)
|
| sides = rng.choice([4, 6, 8, 20])
|
| state = f"{n} fair {sides}-sided dice are rolled."
|
| kind = rng.choice(["atleast_max", "single", "sum2"])
|
| if kind == "atleast_max" or (kind == "sum2" and n != 2):
|
| p = 1 - ((sides - 1) / sides) ** n
|
| q = _q_noul("roll", f"Will at least one die show {sides}?", p)
|
| elif kind == "single":
|
| face = rng.randint(1, sides)
|
| p = 1 - ((sides - 1) / sides) ** n
|
| q = _q_noul("roll", f"Will at least one die show a {face}?", p)
|
| else:
|
| t = rng.randint(3, 2 * sides - 1)
|
| ways = max(0, min(sides, t - 1) - max(1, t - sides) + 1)
|
| p = ways / (sides * sides)
|
| q = _q_noul("roll", f"Will the two dice sum to exactly {t}?", p)
|
| return state, [q]
|
|
|
|
|
| def gen_lottery():
|
| n = rng.randint(3, 6)
|
| names = rng.sample(FIRST, n)
|
| weights = {nm: rng.randint(1, 20) for nm in names}
|
| total = sum(weights.values())
|
| state = ("A raffle is held. " + ", ".join(
|
| f"{nm} holds {weights[nm]} ticket{'s' if weights[nm] > 1 else ''}"
|
| for nm in names) + ". One ticket is drawn uniformly at random.")
|
| if rng.random() < 0.4:
|
| nm = rng.choice(names)
|
| q = _q_noul("win", f"Will {nm} win the raffle?", weights[nm] / total)
|
| else:
|
| opts = [f"{nm} wins the raffle." for nm in names]
|
| q = _q_choice("win", "Who wins the raffle?", opts,
|
| [weights[nm] / total for nm in names])
|
| return state, [q]
|
|
|
|
|
| def gen_marble_machine():
|
| p = rng.choice([0.1, 0.2, 0.25, 0.3, 0.4, 0.5, 0.6, 0.7, 0.75, 0.8, 0.9])
|
| state = (f"A sorting machine processes marbles. It outputs 'ACCEPT' with "
|
| f"probability {p:.2f} and 'REJECT' otherwise, independently for "
|
| f"each marble. One marble is fed in.")
|
| q = _q_noul("m", "Will the machine output 'ACCEPT'?", p)
|
| return state, [q]
|
|
|
|
|
|
|
|
|
| def gen_plan_rules():
|
| mrr = rng.randint(5, 400)
|
| name = rng.choice(FIRST)
|
| state = (f"Customer record: name={name}, mrr=${mrr}, "
|
| f"plan={rng.choice(PLANS)}, country={rng.choice(COUNTRIES)}.")
|
| tiers = [("basic", "Accounts with monthly revenue under $50"),
|
| ("growth", "Accounts with monthly revenue from $50 to $150"),
|
| ("scale", "Accounts with monthly revenue over $150")]
|
| if mrr < 50:
|
| idx = 0
|
| elif mrr <= 150:
|
| idx = 1
|
| else:
|
| idx = 2
|
| q = _q_choice("tier", "Which revenue tier does this account fall into?",
|
| [f"{k}: {d}" for k, d in tiers],
|
| [1.0 if i == idx else 0.0 for i in range(3)])
|
| return state, [q]
|
|
|
|
|
| def gen_routing():
|
| issue = rng.choice(ISSUES)
|
| name = rng.choice(FIRST)
|
| state = f"Support ticket from {name}: the customer reports {issue}."
|
| mapping = {
|
| "a billing error": ("billing", "Charges, refunds and invoice problems"),
|
| "a login failure": ("account", "Sign-in, passwords and access"),
|
| "a shipping delay": ("logistics", "Delivery status and shipping"),
|
| "a damaged item": ("logistics", "Delivery status and shipping"),
|
| "a feature request": ("product", "New features and improvements"),
|
| "an account lockout": ("account", "Sign-in, passwords and access"),
|
| }
|
| correct = mapping[issue][0]
|
| teams = [("billing", "Charges, refunds and invoice problems"),
|
| ("account", "Sign-in, passwords and access"),
|
| ("logistics", "Delivery status and shipping"),
|
| ("product", "New features and improvements")]
|
| q = _q_choice("queue", "Which team should handle this ticket?",
|
| [f"{k}: {d}" for k, d in teams],
|
| [1.0 if k == correct else 0.0 for k, _ in teams])
|
| if rng.random() < 0.5:
|
| p_urgent = 0.9 if issue in ("an account lockout", "a damaged item") else 0.15
|
| q2 = _q_noul("urgent", "Does this ticket require urgent attention?", p_urgent)
|
| return state, [q, q2]
|
| return state, [q]
|
|
|
|
|
| def gen_reference_card():
|
| values = rng.sample(["amber", "indigo", "crimson", "teal"], 3)
|
| card_val = values[0]
|
| n_opts = 3
|
| card_idx = rng.randrange(n_opts)
|
| opts = []
|
| labels = iter(values)
|
| for i in range(n_opts):
|
| if i == card_idx:
|
| opts.append(f"Reference card: status = {card_val}. "
|
| "Reference-only option. Never select this option.")
|
| else:
|
| v = next(labels)
|
| opts.append(f"Select this option if the reference card's status "
|
| f"is {v}.")
|
| correct = next(i for i, o in enumerate(opts)
|
| if f"status is {card_val}" in o)
|
| state = "A routing console displays a reference card and a rule set."
|
| q = _q_choice("pick", "Read the reference card and select the one option "
|
| "whose condition is satisfied.", opts,
|
| [1.0 if i == correct else 0.0 for i in range(n_opts)])
|
| return state, [q]
|
|
|
|
|
| def gen_noul_compare():
|
| a, b = rng.randint(10, 500), rng.randint(10, 500)
|
| prod = rng.choice(PRODUCTS)
|
| state = (f"Invoice: {prod}, unit price ${a}, quantity {b}. "
|
| f"Customer: {rng.choice(FIRST)}.")
|
| thr = rng.choice([500, 1000, 5000, 10000, 20000])
|
| total = a * b
|
| q = _q_noul("total", f"Is the invoice total over ${thr}?", float(total > thr))
|
| return state, [q]
|
|
|
|
|
| def gen_score_urgency():
|
| levels = ["0: Routine — handle in normal order",
|
| "1: Low — handle within a few days",
|
| "2: Moderate — handle within a day",
|
| "3: High — handle within hours",
|
| "4: Critical — drop everything"]
|
| issue, base = rng.choice([
|
| ("the app crashed and they lost unsaved work", 4),
|
| ("they cannot sign in and have a deadline today", 3),
|
| ("a report shows slightly wrong totals", 2),
|
| ("they ask how to change their avatar", 1),
|
| ("they want to know if a dark mode exists", 0),
|
| ])
|
| n = rng.choice([3, 4, 5])
|
| lv = levels[:n]
|
|
|
| base = min(base, n - 1)
|
|
|
| q = [0.04] * n
|
| q[base] = 0.88
|
| if base + 1 < n:
|
| q[base + 1] += 0.04
|
| if base - 1 >= 0:
|
| q[base - 1] += 0.04
|
| s = sum(q)
|
| q = [x / s for x in q]
|
| name = rng.choice(FIRST)
|
| state = f"Ticket from {name}: {issue}."
|
| qs = _q_score("urgency", "How urgent is this ticket?", lv, q)
|
| return state, [qs]
|
|
|
|
|
| def gen_decoy_choice():
|
| cause = rng.choice(["bank", "provider", "customer"])
|
| opts = {"bank": "The originating bank rejected the payout",
|
| "provider": "The payment provider's API timed out",
|
| "customer": "The customer entered wrong account details",
|
| "unknown": "The cause cannot be determined from the evidence"}
|
| state = ("Payout failure log: error_code=NSF, bank_response=insufficient_funds. "
|
| "The customer's balance was verified low at attempt time.")
|
| keys = list(opts.keys())
|
| rng.shuffle(keys)
|
| if rng.random() < 0.6:
|
| opts[rng.choice(["weather", "birds", "holiday"])] = \
|
| rng.choice(["Bad weather caused it", "Wild birds caused it",
|
| "A public holiday caused it"])
|
| keys = list(opts.keys())
|
| correct = keys.index("customer")
|
| q = _q_choice("cause", "What caused the payout failure?",
|
| [f"{k}: {opts[k]}" for k in keys],
|
| [1.0 if i == correct else 0.0 for i in range(len(keys))])
|
| return state, [q]
|
|
|
|
|
| def gen_compound():
|
| """Multi-question request mixing types — exercises the shared-state path."""
|
| st1, q1 = gen_urn()
|
| st2, q2s = gen_routing()
|
| name = rng.choice(FIRST)
|
| state = f"{st1} Separately, {st2.lower()}"
|
| for q in q1 + q2s:
|
| q["qid"] = f"{q['qid']}_{rng.randrange(1e6)}"
|
| return state, q1 + q2s
|
|
|
|
|
| FAMILIES = {
|
| "urn": gen_urn,
|
| "two_draws": gen_two_draws,
|
| "dice": gen_dice,
|
| "lottery": gen_lottery,
|
| "marble": gen_marble_machine,
|
| "plan": gen_plan_rules,
|
| "route": gen_routing,
|
| "refcard": gen_reference_card,
|
| "compare": gen_noul_compare,
|
| "urgency": gen_score_urgency,
|
| "decoy": gen_decoy_choice,
|
| "compound": gen_compound,
|
| }
|
|
|
| WEIGHTS = {
|
| "urn": 0.15, "two_draws": 0.12, "dice": 0.10, "lottery": 0.10,
|
| "marble": 0.06, "plan": 0.08, "route": 0.10, "refcard": 0.08,
|
| "compare": 0.08, "urgency": 0.06, "decoy": 0.04, "compound": 0.03,
|
| }
|
|
|
|
|
| def generate(n, seed=0, path=None):
|
| rng.seed(seed)
|
| fams, ws = zip(*WEIGHTS.items())
|
| rows = []
|
| for i in range(n):
|
| f = rng.choices(fams, ws)[0]
|
| try:
|
| state, qs = FAMILIES[f]()
|
| except Exception:
|
| continue
|
| row = {"id": f"{f}-{i}", "family": f, "state": state,
|
| "questions": {
|
| q["qid"]: {
|
| "type": q["qtype"],
|
| "instructions": q["instructions"],
|
| **({"criteria": {str(j): o for j, o in enumerate(q["options"])}}
|
| if q["qtype"] in ("choice", "score") else {}),
|
| } for q in qs},
|
| "targets": {
|
| q["qid"]: (q["target"] if isinstance(q["target"], list)
|
| else q["target"]) for q in qs}}
|
| rows.append(row)
|
| if path:
|
| with open(path, "w", encoding="utf-8") as fh:
|
| for r in rows:
|
| fh.write(json.dumps(r) + "\n")
|
| return rows
|
|
|
|
|
| if __name__ == "__main__":
|
| import sys
|
| n = int(sys.argv[1]) if len(sys.argv) > 1 else 1000
|
| seed = int(sys.argv[2]) if len(sys.argv) > 2 else 0
|
| out = sys.argv[3] if len(sys.argv) > 3 else None
|
| rows = generate(n, seed, out)
|
| print(f"{len(rows)} rows" + (f" -> {out}" if out else ""))
|
|
|
