#!/usr/bin/env python3 """validate_engine.py — correctness validator for Chinese Standard Mahjong (MCR) engines against the IJCAI-2026 Final Stage-2 golden game set (Dannibal/mcr-final2026-testset). Two modes: 1. Self-test (validates the dataset itself against the reference replay semantics): python3 validate_engine.py --self-test mcr_final2026_full.jsonl.gz [--jobs 64] Replays every game with a pure-python reference checker (the corrected "replay_harness2" semantics: PENG/CHI-embedded discards, live-discard GANG discrimination, BUGANG handling, ron/zimo/qianggang terminal labeling) and asserts, for every game: - wall integrity (136 tiles, 4 of each of the 34 kinds) - deal & draw order: seat s is dealt/draws from wall[34*s .. 34*s+33], consumed from the BACK (index 34*s+33 first); tileCnt bookkeeping - per-step hand/meld legality (every discard from hand, PENG needs 2 in hand, CHI only from the left neighbour with both fillers in hand, melded GANG needs 3, AnGang needs 4 after own draw, BUGANG upgrades an existing PENG) - claim resolution priority (HU > PENG/GANG > CHI) and actor rotation - response<->event consistency (the granted claim's response string must match the following judge event, including the embedded discard) - terminal: ending classification (zimo/ron/draw + qianggang), fan_total == sum(value*cnt) of the fan list, exact score arithmetic (zimo: winner +3*(8+fan), others -(8+fan); ron: winner +(3*8+fan), discarder -(8+fan), bystanders -8), scores sum to 0, and agreement with the record's `expected` block. 2. Engine mode (validates YOUR engine — the product): python3 validate_engine.py --engine mymodule:MyEngine mcr_final2026_golden.jsonl Your engine must implement the interface below. The validator drives it with the logged bot responses turn by turn and requires the engine to reproduce the judge's protocol stream exactly: every per-seat request string, every display event (claim resolutions, gang discrimination, win detection) and the terminal fan/score result. class MyEngine: def reset(self, wall: list[str], quan: int, srand: int) -> dict: '''Start a game. wall = 136 tiles; seat s draws from wall[34*s : 34*s+34], back to front. Returns the first turn: {"requests": {"0": "0 0 0", ...}, "display": {"action": "INIT", ...}}''' def step(self, responses: dict[str, str]) -> dict: '''Feed the four seats' response strings to the pending requests; return the next turn dict: {"requests": {...} or {}, "display": {...}}. The terminal turn's display has action HU (with fan/fanCnt/ score) or HUANG.''' By default `canHu` and `tileCnt` inside displays are compared too (they are exactly reproducible); use --loose to compare only action/player/tile/tileCHI/hand/fan/fanCnt/score. `--demo` runs engine mode with a built-in engine that replays the stored turns (interface smoke test). Dataset: https://huggingface.co/datasets/Dannibal/mcr-final2026-testset """ import argparse import gzip import json import sys from collections import Counter TILE_KINDS = ([c + str(n) for c in "WBT" for n in range(1, 10)] + ["F" + str(n) for n in range(1, 5)] + ["J" + str(n) for n in range(1, 4)]) CLAIM_PRIO = {"HU": 3, "GANG": 2, "PENG": 2, "CHI": 1} class CheckFail(Exception): pass def _ck(cond, msg): if not cond: raise CheckFail(msg) def classify_terminal(displays): """Harness2 terminal semantics from the ordered display stream. Returns dict(ending, winner, discarder, qianggang) — ending in zimo|ron|draw. Ron off a PENG/CHI-embedded discard counts the claimer as discarder; HU immediately after BUGANG is qianggang (robbed kong), discarder = the BUGANG player.""" live = None # (tile, seat) of the unclaimed discard prev = None for d in displays: a = d["action"] if a == "DRAW": live = None elif a in ("PLAY", "PENG", "CHI"): live = (d["tile"], d["player"]) elif a == "GANG": live = None elif a == "BUGANG": live = None elif a == "HUANG": return dict(ending="draw", winner=None, discarder=None, qianggang=False) elif a == "HU": w = d["player"] if prev is not None and prev["action"] == "BUGANG": return dict(ending="ron", winner=w, discarder=prev["player"], qianggang=True) if live is not None: return dict(ending="ron", winner=w, discarder=live[1], qianggang=False) return dict(ending="zimo", winner=w, discarder=None, qianggang=False) prev = d return dict(ending="unknown", winner=None, discarder=None, qianggang=False) def expected_scores(ending, winner, discarder, fan_total): if ending == "draw": return [0, 0, 0, 0] sc = [0, 0, 0, 0] if ending == "zimo": for s in range(4): sc[s] = 3 * (8 + fan_total) if s == winner else -(8 + fan_total) else: # ron (incl. qianggang) for s in range(4): if s == winner: sc[s] = 3 * 8 + fan_total elif s == discarder: sc[s] = -(8 + fan_total) else: sc[s] = -8 return sc def check_record(rec): """Full structural + semantic check of one dataset record. Raises CheckFail on the first violation. Returns a dict of facts (event counts etc.) usable for tagging.""" wall = rec["wall"] _ck(len(wall) == 136, "wall length %d != 136" % len(wall)) _ck(Counter(wall) == Counter({t: 4 for t in TILE_KINDS}), "wall is not 4x each of the 34 tile kinds") segs = [wall[34 * s:34 * s + 34] for s in range(4)] remain = [34, 34, 34, 34] # tiles left in each seat's segment hands = [None] * 4 packs = [[] for _ in range(4)] # (type, tile, offer_seat) live = None # (tile, seat) live unclaimed discard prev_a = prev_p = None turns = rec["turns"] facts = Counter() displays = [t["display"] for t in turns] def hand_ok(s): _ck(len(hands[s]) == 13 - 3 * len(packs[s]), "seat %d hand size %d with %d melds" % (s, len(hands[s]), len(packs[s]))) for k, turn in enumerate(turns): d = turn["display"] a = d["action"] nxt = turns[k + 1]["display"] if k + 1 < len(turns) else None resp = turn.get("responses") or {} if a == "INIT": _ck(d.get("quan") == rec["quan"], "INIT quan mismatch") _ck(d.get("srand") == rec["srand"], "INIT srand mismatch") elif a == "DEAL": for s in range(4): expect = [segs[s][33 - i] for i in range(13)] _ck(d["hand"][s] == expect, "seat %d dealt hand != last-13-reversed of wall segment" % s) hands[s] = list(d["hand"][s]) remain[s] = 21 elif a == "DRAW": s, t = d["player"], d["tile"] _ck(remain[s] > 0, "seat %d draws from empty segment" % s) _ck(segs[s][remain[s] - 1] == t, "draw %s != wall order tile %s" % (t, segs[s][remain[s] - 1])) remain[s] -= 1 _ck(d["tileCnt"][s] == remain[s], "tileCnt mismatch after draw") # rotation: replacement draw after own kong, else next seat if prev_a in ("GANG", "BUGANG"): _ck(s == prev_p, "replacement draw by wrong seat") elif prev_a in ("PLAY", "PENG", "CHI"): _ck(s == (prev_p + 1) % 4, "draw out of rotation") elif prev_a == "DEAL": _ck(s == 0, "first draw not by dealer (seat 0)") live = None hands[s].append(t) # drawer's own response drives the next event r = (resp.get(str(s)) or "").split() if r: if r[0] == "PLAY": _ck(nxt and nxt["action"] == "PLAY" and nxt["player"] == s and nxt["tile"] == r[1], "PLAY response not honored") elif r[0] == "GANG": _ck(nxt and nxt["action"] == "GANG" and nxt["player"] == s and nxt.get("tile") == r[1], "AnGang response not honored") elif r[0] == "BUGANG": _ck(nxt and nxt["action"] == "BUGANG" and nxt["player"] == s and nxt["tile"] == r[1], "BuGang response not honored") elif r[0] == "HU": _ck(nxt and nxt["action"] == "HU" and nxt["player"] == s, "zimo HU response not honored") elif a in ("PLAY", "PENG", "CHI"): s = d["player"] out = d["tile"] if a == "PLAY": _ck(prev_a == "DRAW" and prev_p == s, "PLAY not after own draw") elif a == "PENG": _ck(live is not None and live[1] != s, "PENG with no live discard") ct = live[0] _ck(hands[s].count(ct) >= 2, "PENG without 2 matching tiles in hand") hands[s].remove(ct); hands[s].remove(ct) packs[s].append(("PENG", ct, live[1])) facts["minggang_or_peng"] += 1 facts["peng"] += 1 else: # CHI _ck(live is not None, "CHI with no live discard") ct, ds = live _ck((s - ds) % 4 == 1, "CHI from non-left neighbour") mid = d["tileCHI"] _ck(ct[0] == mid[0] and mid[0] in "WBT", "CHI suit mismatch") m, c = int(mid[1]), int(ct[1]) _ck(c in (m - 1, m, m + 1), "claimed tile not part of chi run") need = [mid[0] + str(x) for x in (m - 1, m, m + 1) if x != c] for tt in need: _ck(tt in hands[s], "CHI filler %s not in hand" % tt) hands[s].remove(tt) packs[s].append(("CHI", mid, ds)) facts["chi"] += 1 # the embedded (PENG/CHI) or plain discard _ck(out in hands[s], "discard %s not in hand" % out) hands[s].remove(out) hand_ok(s) live = (out, s) # claim arbitration on this discard claims = {} for ss in range(4): if ss == s: continue rr = (resp.get(str(ss)) or "PASS").split() if rr and rr[0] != "PASS": claims[ss] = rr if claims: best = max(CLAIM_PRIO.get(rr[0], 0) for rr in claims.values()) winners = [ss for ss, rr in claims.items() if CLAIM_PRIO.get(rr[0], 0) == best] if len(winners) > 1: # multiple HU on one tile: nearest downstream facts["multi_hu"] += 1 winners = sorted(winners, key=lambda ss: (ss - s) % 4)[:1] if len(claims) > 1: facts["multi_claim"] += 1 ws = winners[0] rr = claims[ws] _ck(nxt is not None, "claim pending but log ended") _ck(nxt["player"] == ws, "claim priority: expected seat %d to act next" % ws) _ck({"HU": "HU", "PENG": "PENG", "CHI": "CHI", "GANG": "GANG"}[rr[0]] == nxt["action"], "granted claim %s != next event %s" % (rr[0], nxt["action"])) if rr[0] == "PENG": _ck(nxt["tile"] == rr[1], "PENG follow-up discard mismatch") elif rr[0] == "CHI": _ck(nxt["tileCHI"] == rr[1] and nxt["tile"] == rr[2], "CHI mid/follow-up mismatch") else: _ck(nxt is not None and nxt["action"] in ("DRAW", "HUANG"), "no claim: expected DRAW/HUANG next, got %s" % (nxt and nxt["action"])) elif a == "GANG": s = d["player"] t = d.get("tile") if live is not None: # melded gang of the live discard ct, ds = live _ck(s != ds, "GANG own discard") _ck(t == ct, "melded GANG tile %s != live discard %s" % (t, ct)) _ck(hands[s].count(ct) == 3, "melded GANG without 3 in hand") for _ in range(3): hands[s].remove(ct) packs[s].append(("GANG", ct, ds)) live = None facts["minggang"] += 1 else: # concealed kong after own draw _ck(prev_a == "DRAW" and prev_p == s, "AnGang not after own draw") _ck(hands[s].count(t) == 4, "AnGang without 4 in hand") for _ in range(4): hands[s].remove(t) packs[s].append(("ANGANG", t, s)) facts["angang"] += 1 _ck(nxt is not None and ((nxt["action"] == "DRAW" and nxt["player"] == s) or nxt["action"] == "HUANG"), "no replacement draw after GANG") elif a == "BUGANG": s, t = d["player"], d["tile"] up = [p for p in packs[s] if p[0] == "PENG" and p[1] == t] _ck(up, "BUGANG without matching PENG meld") _ck(t in hands[s], "BUGANG tile not in hand") hands[s].remove(t) packs[s][packs[s].index(up[0])] = ("GANG", t, up[0][2]) live = None facts["bugang"] += 1 # qianggang arbitration hus = [ss for ss in range(4) if ss != s and (resp.get(str(ss)) or "PASS").split()[:1] == ["HU"]] if hus: _ck(nxt is not None and nxt["action"] == "HU" and nxt["player"] in hus, "qianggang HU not honored") else: _ck(nxt is not None and ((nxt["action"] == "DRAW" and nxt["player"] == s) or nxt["action"] == "HUANG"), "no replacement draw after BUGANG") elif a == "HUANG": nxt_drawer = (prev_p + 1) % 4 if prev_a in ("PLAY", "PENG", "CHI") \ else prev_p _ck(remain[nxt_drawer] == 0, "HUANG but next drawer still has %d wall tiles" % remain[nxt_drawer]) elif a == "HU": pass # terminal block checked below else: raise CheckFail("unknown display action %r" % a) prev_a, prev_p = a, d.get("player", prev_p) # ---- terminal / expected block ---- exp = rec["expected"] cls = classify_terminal(displays) _ck(cls["ending"] == exp["ending"], "ending %s != expected %s" % (cls["ending"], exp["ending"])) _ck(cls["winner"] == exp["winner"], "winner mismatch") _ck(cls["discarder"] == exp["discarder"], "discarder mismatch") _ck(cls["qianggang"] == exp["qianggang"], "qianggang flag mismatch") last = displays[-1] if exp["ending"] == "draw": _ck(last["action"] == "HUANG", "draw game does not end with HUANG") _ck(exp["scores"] == [0, 0, 0, 0], "draw scores not all 0") _ck(exp["fan_total"] == 0 and exp["fan"] == [], "draw with fan") else: _ck(last["action"] == "HU", "hu game does not end with HU") fan_sum = sum(v * c for _, v, c in exp["fan"]) _ck(fan_sum == exp["fan_total"], "fan list sums to %d != fan_total %d" % (fan_sum, exp["fan_total"])) _ck(last["fanCnt"] == exp["fan_total"], "display fanCnt != fan_total") _ck(list(last["score"]) == list(exp["scores"]), "display score != expected") want = expected_scores(exp["ending"], exp["winner"], exp["discarder"], exp["fan_total"]) _ck(want == list(exp["scores"]), "score arithmetic: computed %s != logged %s" % (want, exp["scores"])) _ck(exp["fan_total"] >= 8, "winning hand below the 8-fan minimum") _ck(sum(exp["scores"]) == 0, "scores do not sum to 0") facts[exp["ending"]] += 1 return dict(facts) # ---------------------------------------------------------------- engine mode LOOSE_KEYS = ("action", "player", "tile", "tileCHI", "hand", "fan", "fanCnt", "score") def _disp_eq(a, b, loose): if loose: return all(a.get(k) == b.get(k) for k in LOOSE_KEYS) ka = {k: v for k, v in a.items() if v is not None} kb = {k: v for k, v in b.items() if v is not None} return ka == kb class DemoReplayEngine: """Interface demo: 'engine' that replays the record's own stored turns.""" def bind(self, rec): self._turns = rec["turns"] self._i = 0 def reset(self, wall, quan, srand): self._i = 0 return self._emit() def step(self, responses): return self._emit() def _emit(self): t = self._turns[self._i] self._i += 1 return {"requests": t.get("request") or {}, "display": t["display"]} def run_engine(engine, rec, loose=False): """Drive `engine` through one game; raise CheckFail on first divergence.""" turns = rec["turns"] out = engine.reset(list(rec["wall"]), rec["quan"], rec["srand"]) for k, turn in enumerate(turns): _ck(_disp_eq(out["display"], turn["display"], loose), "turn %d display diverged:\n engine: %s\n oracle: %s" % (k, json.dumps(out["display"], ensure_ascii=False), json.dumps(turn["display"], ensure_ascii=False))) if turn.get("request"): _ck(out.get("requests") == turn["request"], "turn %d request strings diverged" % k) if k + 1 < len(turns): out = engine.step(dict(turn.get("responses") or {})) # --------------------------------------------------------------------- driver def iter_records(path): op = gzip.open if path.endswith(".gz") else open with op(path, "rt", encoding="utf-8") as f: for line in f: line = line.strip() if line: yield json.loads(line) def _self_one(line): rec = json.loads(line) try: check_record(rec) return (rec["game_id"], None, rec.get("tags", [])) except CheckFail as e: return (rec["game_id"], str(e), rec.get("tags", [])) except Exception as e: # noqa: BLE001 return (rec["game_id"], "internal: %r" % e, rec.get("tags", [])) def main(): ap = argparse.ArgumentParser(description=__doc__.split("\n")[0]) ap.add_argument("dataset", help=".jsonl or .jsonl.gz test file") ap.add_argument("--self-test", action="store_true", help="validate the dataset against the reference replay") ap.add_argument("--engine", metavar="module:Class", help="validate an engine implementation") ap.add_argument("--demo", action="store_true", help="engine mode with the built-in replay engine") ap.add_argument("--loose", action="store_true", help="engine mode: compare only core display keys") ap.add_argument("--jobs", type=int, default=1) ap.add_argument("--limit", type=int, default=0) args = ap.parse_args() if args.self_test: op = gzip.open if args.dataset.endswith(".gz") else open with op(args.dataset, "rt", encoding="utf-8") as f: lines = [ln for ln in f if ln.strip()] if args.limit: lines = lines[:args.limit] if args.jobs > 1: import multiprocessing as mp with mp.Pool(args.jobs) as pool: results = pool.map(_self_one, lines, chunksize=16) else: results = [_self_one(ln) for ln in lines] fails = [(g, e) for g, e, _ in results if e] n_disc = sum(1 for _, _, tags in results if "gb_discrepancy" in tags) print("self-test: %d/%d games PASS (%d known-discrepancy games included" " — they pass: the judge is the ground truth)" % (len(results) - len(fails), len(results), n_disc)) for g, e in fails[:20]: print("FAIL %s: %s" % (g, e)) sys.exit(1 if fails else 0) if args.demo or args.engine: if args.demo: eng = DemoReplayEngine() else: modname, clsname = args.engine.split(":") mod = __import__(modname) eng = getattr(mod, clsname)() n = ok = 0 for rec in iter_records(args.dataset): n += 1 if args.limit and n > args.limit: n -= 1 break if args.demo: eng.bind(rec) try: run_engine(eng, rec, loose=args.loose) ok += 1 except CheckFail as e: print("FAIL %s: %s" % (rec["game_id"], e)) print("engine mode: %d/%d games reproduced exactly" % (ok, n)) sys.exit(0 if ok == n else 1) ap.error("choose --self-test, --engine or --demo") if __name__ == "__main__": main()