"""Monte-Carlo simulation of the 2026 World Cup under the real 48-team format. Group stage scorelines are sampled from the Dixon-Coles joint grid; group standings use FIFA tiebreakers (points, GD, GF). The 8 best third-placed teams are selected and allocated to bracket slots via Annex-C cluster matching; the fixed single-elimination bracket is then played out, with draws in knockout matches resolved in proportion to regulation win strength (ET/penalties).""" from __future__ import annotations import json import time import networkx as nx import numpy as np import config from db import connect import bracket as B from wcmodel import WorldCupModel, load_training_frame # ---------------------------------------------------------------- caches def build_caches(model: WorldCupModel, groups: dict[str, list[str]]): """Precompute group-stage scoreline samplers and a knockout win matrix.""" teams = sorted({t for ts in groups.values() for t in ts}) idx = {t: i for i, t in enumerate(teams)} n = len(teams) with connect() as conn: fixtures = conn.execute( "SELECT home_team,away_team,neutral FROM matches " "WHERE stage='group' ORDER BY date,id" ).fetchall() # group-stage fixtures -> flattened cumulative distribution over scorelines gs = [] for f in fixtures: g = model.predict_grid(f["home_team"], f["away_team"], neutral=bool(f["neutral"])) grid = np.asarray(g.grid) flat = grid.ravel() flat = flat / flat.sum() gs.append((f["home_team"], f["away_team"], np.cumsum(flat), grid.shape[1])) # knockout: advance-probability matrix (neutral venue), team i beats team j adv = np.zeros((n, n)) for a in teams: for b in teams: if a == b: continue g = model.predict_grid(a, b, neutral=True) ph, pdr, pa = (float(x) for x in g.home_draw_away) denom = ph + pa adv[idx[a], idx[b]] = ph + (pdr * ph / denom if denom > 0 else 0.5 * pdr) return teams, idx, gs, adv # ---------------------------------------------------------------- one sim def _rank(table: dict) -> list[str]: """Sort teams by points, goal difference, goals for, then random jitter.""" return sorted( table, key=lambda t: (table[t]["pts"], table[t]["gd"], table[t]["gf"], table[t]["r"]), reverse=True, ) def _assign_thirds(third_groups: list[str], rng) -> dict[int, str]: """Match the 8 qualified third-place groups to the 8 bracket slots so each lands in an Annex-C-permitted cluster (bipartite maximum matching).""" G = nx.Graph() slots = list(B.THIRD_SLOTS) for mid in slots: G.add_node(("slot", mid)) for grp in third_groups: G.add_node(("grp", grp)) for mid in slots: if grp in B.THIRD_SLOTS[mid]: G.add_edge(("grp", grp), ("slot", mid)) m = nx.bipartite.maximum_matching(G, top_nodes={("grp", g) for g in third_groups}) return {mid: m[("slot", mid)][1] for mid in slots if ("slot", mid) in m} def simulate_once(groups, idx, gs, adv, rng) -> tuple[dict, str]: # ---- group stage ---- tables = {g: {t: {"pts": 0, "gf": 0, "ga": 0, "gd": 0, "r": rng.random()} for t in ts} for g, ts in groups.items()} team_group = {t: g for g, ts in groups.items() for t in ts} ncol = gs[0][3] for home, away, cum, _nc in gs: k = int(np.searchsorted(cum, rng.random())) hs, as_ = divmod(k, ncol) g = team_group[home] th, ta = tables[g][home], tables[g][away] th["gf"] += hs; th["ga"] += as_; ta["gf"] += as_; ta["ga"] += hs if hs > as_: th["pts"] += 3 elif hs < as_: ta["pts"] += 3 else: th["pts"] += 1; ta["pts"] += 1 for g in tables: for t in tables[g]: tables[g][t]["gd"] = tables[g][t]["gf"] - tables[g][t]["ga"] winners, runners, thirds = {}, {}, [] reached = {} # team -> furthest stage code for g, tbl in tables.items(): order = _rank(tbl) winners[g], runners[g] = order[0], order[1] thirds.append((g, order[2], tbl[order[2]])) for t in order: reached[t] = "group" # best 8 third-placed teams thirds.sort(key=lambda x: (x[2]["pts"], x[2]["gd"], x[2]["gf"], x[2]["r"]), reverse=True) best8 = thirds[:8] third_team_of_group = {g: t for g, t, _ in best8} slot_group = _assign_thirds([g for g, _, _ in best8], rng) third_for_slot = {mid: third_team_of_group[slot_group[mid]] for mid in slot_group} # ---- resolve R32 entrants ---- def resolve(slot): kind, val = slot if kind == "W": return winners[val] if kind == "RU": return runners[val] return None # third slots filled below qualified = set() match_team = {} for mid, (sa, sb) in B.R32.items(): ta = resolve(sa) tb = resolve(sb) if sb[0] != "3" else third_for_slot[mid] match_team[mid] = [ta, tb] qualified.update([ta, tb]) for t in qualified: reached[t] = "R32" # ---- play knockout bracket ---- def play(mid): ta, tb = match_team[mid] pa = adv[idx[ta], idx[tb]] winner = ta if rng.random() < pa else tb return winner # R32 r32_winners = {mid: play(mid) for mid in B.R32} for w in r32_winners.values(): reached[w] = "R16" # subsequent rounds use FEED winners_by_match = dict(r32_winners) next_stage_code = {"R16": "QF", "QF": "SF", "SF": "F", "F": "champion"} for mid in (89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104): a, b = B.FEED[mid] match_team[mid] = [winners_by_match[a], winners_by_match[b]] w = play(mid) winners_by_match[mid] = w reached[w] = next_stage_code[B.STAGE_OF[mid]] champion = winners_by_match[104] return reached, champion, winners # ---------------------------------------------------------------- aggregate STAGES = ["group", "R32", "R16", "QF", "SF", "F", "champion"] # cumulative "reached at least" mapping REACH_AT_LEAST = { "p_advance": ["R32", "R16", "QF", "SF", "F", "champion"], "p_r16": ["R16", "QF", "SF", "F", "champion"], "p_qf": ["QF", "SF", "F", "champion"], "p_sf": ["SF", "F", "champion"], "p_final": ["F", "champion"], "p_win": ["champion"], } def run(n_sims: int = 20000, seed: int = 12345) -> dict: groups = json.loads((config.PROCESSED / "groups.json").read_text(encoding="utf-8")) model = WorldCupModel.load() teams, idx, gs, adv = build_caches(model, groups) rng = np.random.default_rng(seed) counts = {t: {k: 0 for k in REACH_AT_LEAST} for t in teams} group_win = {t: 0 for t in teams} t0 = time.time() for _ in range(n_sims): reached, champ, winners = simulate_once(groups, idx, gs, adv, rng) for w in winners.values(): group_win[w] += 1 for t, st in reached.items(): for key, ok in REACH_AT_LEAST.items(): if st in ok: counts[t][key] += 1 dt = time.time() - t0 team_group = {t: g for g, ts in groups.items() for t in ts} results = [] for t in teams: c = counts[t] results.append({ "team": t, "group": team_group[t], "p_group_win": round(group_win[t] / n_sims, 4), "p_advance": round(c["p_advance"] / n_sims, 4), "p_r16": round(c["p_r16"] / n_sims, 4), "p_qf": round(c["p_qf"] / n_sims, 4), "p_sf": round(c["p_sf"] / n_sims, 4), "p_final": round(c["p_final"] / n_sims, 4), "p_win": round(c["p_win"] / n_sims, 4), }) results.sort(key=lambda r: r["p_win"], reverse=True) print(f"{n_sims} sims in {dt:.1f}s ({n_sims/dt:.0f}/s)") return {"n_sims": n_sims, "results": results} def store(sim: dict, run_id: int) -> None: with connect() as conn: conn.execute("DELETE FROM simulations WHERE run_id=?", (run_id,)) conn.executemany( """INSERT INTO simulations(run_id,team,group_label,p_group_win, p_advance,p_r16,p_qf,p_sf,p_final,p_win,exp_points) VALUES(?,?,?,?,?,?,?,?,?,?,?)""", [(run_id, r["team"], r["group"], r["p_group_win"], r["p_advance"], r["p_r16"], r["p_qf"], r["p_sf"], r["p_final"], r["p_win"], 0.0) for r in sim["results"]], ) if __name__ == "__main__": import sys n = int(sys.argv[1]) if len(sys.argv) > 1 else 20000 out = run(n) print("\nTitle odds (top 12):") for r in out["results"][:12]: print(f" {r['team']:<16} {r['group']} win={r['p_win']*100:5.2f}% " f"final={r['p_final']*100:5.1f}% adv={r['p_advance']*100:5.1f}%")