code/rules7.py

"""Jev Rules-7: rule and policy decision tasks (evaluation only). Facts in the state, the policy RULE IN THE QUESTION,
gold computed exactly by code for the generated tasks; ShARC dev and the patent phrase test split are pinned public
sets. Skills: admission, rental, agent_rules, authority, fraud_points, sharc, patent_phrases, missing_facts (paired
complete / one-fact-removed records for the AUROC of the model's confidence).
"""

import gzip
import hashlib
import json
import random

import bench_common as X
from bench_common import choice, noul, noul_target, onehot, score as score_q

VERSION = "v1"
BENCH = "Rules7"
SKILLS = ("admission", "rental", "agent_rules", "authority", "fraud_points", "sharc", "patent_phrases", "missing_facts")
SIZES = {"admission": 400, "rental": 400, "agent_rules": 400, "authority": 400, "fraud_points": 400, "sharc": 400,
         "patent_phrases": 400, "missing_facts": 160}  # missing_facts: pairs per task (two tasks, two items per pair)
LICENSE = "CC0-1.0"
SHARC = ("tasksource/sharc", "fa4605de8281290c69af9dea6118b37d072c2b59", "data/validation-00000-of-00001.parquet")
PATENT = ("tasksource/patent-phrase-similarity", "ff1868796e44ac9ec02e870b447fde6c5bf2d6e4",
          "data/test-00000-of-00001-c5556affccbcc71f.parquet")

NAMES = ["Alex Moreno", "Priya Raman", "Chen Wei", "Sara Lindqvist", "Tomasz Nowak", "Amara Okafor", "Lucas Ferreira",
         "Yuki Tanaka", "Fatima Zahra", "Noah Becker", "Elena Petrova", "Diego Salazar", "Ines Costa", "Omar Haddad"]


def _item(id, skill, source, state, questions, targets, license=LICENSE, split="generated", **extra):
    st = state if isinstance(state, str) else json.dumps(state, ensure_ascii=False)
    key = st + " " + " ".join(q["instructions"] for q in questions.values())
    it = X._item(id, skill, source, st, questions, targets, license, key)
    it.update(bench=BENCH, split=split, **extra)
    return it


# ===================================================================== a small rule engine with missing facts
class Cond:
    """One condition on one fact: kind ge / le (numeric threshold t), bool, notbool, in (value in `opts`)."""

    def __init__(s, spec: dict, rng: random.Random):
        s.key, s.kind = spec["key"], spec["kind"]
        s.spec = spec
        s.t = rng.choice(spec["ts"]) if "ts" in spec else None
        s.opts = spec.get("opts")
        s.phrase = spec["phrase"].format(t=s.t) if "phrase" in spec else None
        s.exc = spec.get("exc")

    def test(s, v):
        if s.kind == "ge":
            return v >= s.t
        if s.kind == "le":
            return v <= s.t
        if s.kind == "lt":
            return v < s.t
        if s.kind == "bool":
            return bool(v)
        if s.kind == "notbool":
            return not v
        return v in s.opts

    def sample(s, rng: random.Random, truth: bool):
        sp = s.spec
        if s.kind in ("bool", "notbool"):
            return truth if s.kind == "bool" else (not truth)
        if s.kind == "in":
            return rng.choice(s.opts if truth else sp["other"])
        if s.kind == "lt":
            return max(sp["lo"], s.t - 1 - rng.choice([0, 0, 1, 2, 5])) if truth else s.t + rng.choice([0, 1, 3, 10, 60])
        step, dec = sp.get("step", 1), sp.get("dec", 0)
        d = rng.choice([0, 1, 1, 2, 3, 5, 9]) * step
        up = (s.kind == "ge") == truth  # value above the threshold
        if not truth:
            d = max(d, step)
        v = s.t + d if up else s.t - d
        v = min(sp["hi"], max(sp["lo"], v))
        v = round(v, dec) if dec else int(round(v))
        if s.test(v) != truth:  # clipped into the wrong side: fall back to the boundary
            v = s.t if truth else (s.t - step if s.kind == "ge" else s.t + step)
            v = round(v, dec) if dec else int(round(v))
        return v


def ev3(node, facts):
    """Kleene evaluation: True / False / None (a needed fact is missing)."""
    t = node[0]
    if t == "c":
        c = node[1]
        return None if c.key not in facts else bool(c.test(facts[c.key]))
    if t == "not":
        v = ev3(node[1], facts)
        return None if v is None else (not v)
    vals = [ev3(n, facts) for n in node[1]]
    if t == "and":
        return False if False in vals else (None if None in vals else True)
    return True if True in vals else (None if None in vals else False)


def conds_of(node):
    if node[0] == "c":
        return [node[1]]
    if node[0] == "not":
        return conds_of(node[1])
    return [c for n in node[1] for c in conds_of(n)]


def build_tree(rng: random.Random, pool: list, exc_pool: list, n: int = 3, allow_exc: bool = True):
    specs = rng.sample(pool, n)
    cs = [("c", Cond(sp, rng)) for sp in specs]
    form = rng.choice(["and", "and", "or_in", "or_out"])
    if form == "and" or n < 3:
        node = ("and", cs)
    elif form == "or_in":
        node = ("and", [cs[0], ("or", cs[1:])])
    else:
        node = ("or", [("and", cs[:2]), cs[2]])
    if allow_exc and exc_pool and rng.random() < 0.4:
        e = ("not", ("c", Cond(rng.choice(exc_pool), rng)))
        node = ("and", [node, e]) if node[0] != "and" else ("and", node[1] + [e])
    return node


def render_tree(node):
    """The tree as a phrase for a sentence; a nested or reads "either ... or ..."."""
    if node[0] == "c":
        return node[1].phrase
    if node[0] == "or":
        sep = ", or " if any(m[0] != "c" for m in node[1]) else " or "
        return "either " + sep.join(render_tree(m) for m in node[1])
    parts = [render_tree(n) for n in node[1] if n[0] != "not"]
    exc = [n[1][1].exc for n in node[1] if n[0] == "not"]
    s = parts[0] if len(parts) == 1 else ", ".join(parts[:-1]) + " and " + parts[-1]
    return s + (", unless the applicant " + " or ".join(exc) if exc else "")


def sample_facts(rng: random.Random, node, target: bool, tries: int = 300):
    cs = conds_of(node)
    for _ in range(tries):
        p = rng.choice([0.3, 0.5, 0.7, 0.9])
        facts = {}
        for c in cs:
            if c.key in facts:
                continue
            facts[c.key] = c.sample(rng, rng.random() < (1 - p if c.exc else p))
        if ev3(node, facts) == target:
            return facts
    return None


def pivots(node, facts):
    """Facts whose removal leaves the outcome undecided."""
    return [k for k in facts if ev3(node, {a: b for a, b in facts.items() if a != k}) is None]


# ===================================================================== admission
ADM_POOL = [
    dict(key="gpa", kind="ge", ts=[2.8, 3.0, 3.2, 3.4, 3.6], lo=2.0, hi=4.0, step=0.1, dec=1, phrase="has a GPA of at least {t}"),
    dict(key="entrance_exam_score", kind="ge", ts=[60, 65, 70, 75, 80], lo=30, hi=100, phrase="scored at least {t} on the entrance exam"),
    dict(key="recommendation_letters", kind="ge", ts=[2, 3, 4], lo=0, hi=6, phrase="has at least {t} recommendation letters"),
    dict(key="years_of_work_experience", kind="ge", ts=[2, 3, 5, 8], lo=0, hi=20, phrase="has at least {t} years of work experience"),
    dict(key="age", kind="le", ts=[28, 30, 35, 40], lo=17, hi=55, phrase="is at most {t} years old"),
    dict(key="submitted_before_deadline", kind="bool", phrase="submitted the application before the deadline"),
    dict(key="portfolio_included", kind="bool", phrase="included a portfolio"),
    dict(key="application_fee_paid", kind="bool", phrase="paid the application fee"),
    dict(key="highest_degree", kind="in", opts=["bachelor's degree", "master's degree", "doctorate"],
         other=["high school diploma", "associate degree", "none"], phrase="holds a bachelor's degree or higher"),
]
ADM_EXC = [
    dict(key="disciplinary_record", kind="bool", exc="has a disciplinary record"),
    dict(key="plagiarism_flag", kind="bool", exc="has a plagiarism flag on file"),
    dict(key="unpaid_tuition", kind="bool", exc="owes unpaid tuition from an earlier enrolment"),
]
ADM_EXTRA = {"applicant": lambda r: r.choice(NAMES), "intended_program": lambda r: r.choice(
    ["Chemistry", "Economics", "Computer Science", "History", "Nursing", "Design", "Physics"]),
    "country": lambda r: r.choice(["Poland", "Brazil", "Japan", "Kenya", "Canada", "Germany", "India"])}
ADM_LEADS = ("Our admissions policy accepts an applicant who {r}. Should this applicant be admitted?",
             "Policy: an applicant is admitted if the applicant {r}. Should this applicant be admitted?",
             "The programme admits an applicant who {r}. Based on the record, should this applicant be admitted?")


def gen_admission(rng: random.Random, target: bool):
    for _ in range(100):
        node = build_tree(rng, ADM_POOL, ADM_EXC, n=rng.choice([2, 3, 3, 4]))
        facts = sample_facts(rng, node, target)
        if facts is None:
            continue
        text = rng.choice(ADM_LEADS).format(r=render_tree(node))
        state = {k: f(rng) for k, f in ADM_EXTRA.items()}
        items = list(facts.items())
        rng.shuffle(items)
        state.update(dict(items))
        return node, state, facts, text
    raise RuntimeError("admission generator failed")


def admission(n: int, rng: random.Random) -> list:
    out = []
    for i in range(n):
        target = i % 2 == 0
        node, state, facts, text = gen_admission(rng, target)
        assert ev3(node, facts) == target
        out.append(_item(f"rules7-admission-{i:04d}", "admission", "rules7:admission", state, {"admit": noul(text)},
                         {"admit": noul_target(target)}))
    return out


# ===================================================================== agent_rules
AGENT = {
    "spend money": dict(
        pool=[dict(key="amount_usd", kind="le", ts=[50, 100, 250, 500, 1000], lo=1, hi=3000, step=10, phrase="the amount is at most ${t}"),
              dict(key="vendor_on_approved_list", kind="bool", phrase="the vendor is on the approved list"),
              dict(key="manager_approved", kind="bool", phrase="a manager has approved it"),
              dict(key="budget_remaining_usd", kind="ge", ts=[500, 1000, 2000], lo=0, hi=6000, step=50, phrase="the remaining budget is at least ${t}")],
        exc=[dict(key="purchase_is_recurring", kind="bool", exc="is a recurring subscription")],
        stem="Spending money", extra={"description": ["software licence", "conference ticket", "cloud credits", "office supplies"]}),
    "send an email": dict(
        pool=[dict(key="recipient_is_internal", kind="bool", phrase="the recipient is inside the company"),
              dict(key="contains_customer_data", kind="notbool", phrase="the message contains no customer data"),
              dict(key="manager_approved", kind="bool", phrase="a manager has approved it"),
              dict(key="recipient_count", kind="le", ts=[1, 3, 5, 10], lo=1, hi=30, phrase="it goes to at most {t} recipients")],
        exc=[dict(key="marketing_content", kind="bool", exc="is marketing content")],
        stem="Sending an email", extra={"subject": ["Quarterly numbers", "Meeting notes", "Invoice question", "Launch update"]}),
    "delete a file": dict(
        pool=[dict(key="location", kind="in", opts=["sandbox"], other=["staging", "production", "shared drive"], phrase="the file is in the sandbox"),
              dict(key="backup_exists", kind="bool", phrase="a backup exists"),
              dict(key="file_age_days", kind="ge", ts=[30, 90, 180, 365], lo=0, hi=900, step=10, phrase="the file is at least {t} days old"),
              dict(key="created_by_agent", kind="bool", phrase="the agent created the file")],
        exc=[dict(key="under_legal_hold", kind="bool", exc="is under legal hold")],
        stem="Deleting a file", extra={"file": ["report_q3.csv", "tmp_export.json", "notes.txt", "build.log"]}),
    "deploy code": dict(
        pool=[dict(key="tests_passed", kind="bool", phrase="all tests passed"),
              dict(key="reviewer_approvals", kind="ge", ts=[1, 2, 3], lo=0, hi=5, phrase="at least {t} reviewers approved it"),
              dict(key="lines_changed", kind="le", ts=[100, 300, 500, 1000], lo=1, hi=2500, step=20, phrase="the change touches at most {t} lines"),
              dict(key="rollback_plan", kind="bool", phrase="a rollback plan is attached")],
        exc=[dict(key="change_freeze", kind="bool", exc="is during a change freeze")],
        stem="Deploying code", extra={"service": ["billing-api", "web-frontend", "search-index", "auth"]}),
    "read data": dict(
        pool=[dict(key="data_sensitivity_level", kind="le", ts=[1, 2, 3], lo=1, hi=5, phrase="the data sensitivity level is at most {t}"),
              dict(key="purpose_logged", kind="bool", phrase="the purpose is logged"),
              dict(key="user_consented", kind="bool", phrase="the user consented"),
              dict(key="requester_in_team", kind="bool", phrase="the requester is in the owning team")],
        exc=[dict(key="subject_is_minor", kind="bool", exc="involves a minor's data")],
        stem="Reading data", extra={"dataset": ["orders", "support tickets", "telemetry", "payroll"]}),
}
AGENT_LEADS = ("Rules for the agent: ", "The agent works under these rules. ", "Agent policy: ")


def agent_rules(n: int, rng: random.Random, with_missing: bool = False) -> list:
    out = []
    for i in range(n):
        target = i % 2 == 0
        for _ in range(100):
            kinds = rng.sample(list(AGENT), 3)
            trees = {k: build_tree(rng, AGENT[k]["pool"], AGENT[k]["exc"], n=3) for k in kinds}
            act = rng.choice(kinds)
            facts = sample_facts(rng, trees[act], target)
            if facts is not None:
                break
        rules = []
        for k in kinds:
            nd = trees[k]
            body = render_tree(nd).replace(", unless the applicant", ", unless the action")
            rules.append(f"{AGENT[k]['stem']} is allowed only if {body}.")
        state = {"requested action": act, **{kk: rng.choice(vv) for kk, vv in AGENT[act]["extra"].items()}, **facts}
        text = rng.choice(AGENT_LEADS) + " ".join(f"({j + 1}) {r}" for j, r in enumerate(rules)) + \
            " May the agent take the requested action?"
        out.append(_item(f"rules7-agent_rules-{i:04d}", "agent_rules", "rules7:agent_rules", state,
                         {"allowed": noul(text)}, {"allowed": noul_target(ev3(trees[act], facts))}))
        assert ev3(trees[act], facts) == target
    return out


# ===================================================================== rental
RENT_OPTS = {"decline": "the rental is refused", "approve": "the rental is approved at the standard terms",
             "approve_with_surcharge": "approved with a young-driver surcharge",
             "require_deposit": "approved but a security deposit is required",
             "surcharge_and_deposit": "approved with both a surcharge and a deposit"}


def gen_rental(rng: random.Random, want: str):
    for _ in range(500):
        min_age = rng.choice([21, 23, 25])
        young = rng.choice([25, 27, 30])
        lic = rng.choice([1, 2, 3])
        dep_rule = rng.choice(["luxury", "debit", "either"])
        dui = rng.choice([3, 5])
        facts = {"renter_age": rng.randint(min_age - 3, 45), "licence_years": rng.randint(0, 8),
                 "vehicle_class": rng.choice(["economy", "compact", "suv", "luxury"]),
                 "payment_method": rng.choice(["credit card", "debit card"]),
                 "dui_conviction_years_ago": rng.choice([None, None, 1, 2, 4, 6, 10]),
                 "rental_days": rng.randint(1, 21)}
        decline = facts["renter_age"] < min_age or facts["licence_years"] < lic or \
            (facts["dui_conviction_years_ago"] is not None and facts["dui_conviction_years_ago"] < dui)
        sur = facts["renter_age"] < young
        dep = {"luxury": facts["vehicle_class"] == "luxury", "debit": facts["payment_method"] == "debit card",
               "either": facts["vehicle_class"] == "luxury" or facts["payment_method"] == "debit card"}[dep_rule]
        gold = "decline" if decline else ("surcharge_and_deposit" if sur and dep else "approve_with_surcharge" if sur
                                           else "require_deposit" if dep else "approve")
        if gold != want:
            continue
        dep_txt = {"luxury": "the vehicle is in the luxury class", "debit": "the renter pays by debit card",
                   "either": "the vehicle is in the luxury class or the renter pays by debit card"}[dep_rule]
        text = (f"Rental policy: refuse the rental if the renter is under {min_age}, has held a licence for less than "
                f"{lic} year{'s' if lic > 1 else ''}, or has a DUI conviction within the last {dui} years. "
                f"Otherwise approve it, adding a young-driver surcharge if the renter is under {young}, and requiring a "
                f"security deposit if {dep_txt}. What should we do with this rental request?")
        return facts, text, gold
    raise RuntimeError("rental generator failed")


def rental(n: int, rng: random.Random) -> list:
    order = list(RENT_OPTS)
    out = []
    for i in range(n):
        facts, text, gold = gen_rental(rng, order[i % len(order)])
        state = {"renter": rng.choice(NAMES), **{k: v for k, v in facts.items() if v is not None}}
        if facts["dui_conviction_years_ago"] is None:
            state["dui_conviction"] = "none on record"
        opts = list(RENT_OPTS)
        rng.shuffle(opts)
        out.append(_item(f"rules7-rental-{i:04d}", "rental", "rules7:rental", state,
                         {"decision": choice(text, {o: RENT_OPTS[o] for o in opts})}, {"decision": onehot(opts, gold)}))
    return out


# ===================================================================== authority
ROLES = {"team_lead": "a team lead", "department_head": "a department head", "cfo": "the CFO",
         "general_counsel": "the general counsel", "hr_director": "the HR director"}


def gen_authority(rng: random.Random, want: str):
    for _ in range(500):
        t1 = rng.choice([200, 500, 1000, 2000])
        t2 = t1 * rng.choice([5, 10])
        rtype = rng.choice(["purchase", "purchase", "contract", "hire", "travel", "software licence"])
        amount = int(rng.choice([t1 * 0.3, t1 * 0.9, t1, t1 * 1.1, t2 * 0.5, t2, t2 * 1.2, t2 * 3]))
        salary_cap = rng.choice([60000, 80000, 100000])
        salary = rng.choice([salary_cap - 10000, salary_cap, salary_cap + 5000, salary_cap + 30000])
        facts = {"request_type": rtype, "requested_by": rng.choice(NAMES)}
        if rtype == "hire":
            facts["annual_salary_usd"] = salary
            gold = "department_head" if salary <= salary_cap else "hr_director"
        else:
            facts["amount_usd"] = amount
            if rtype == "contract":
                gold = "general_counsel"
            elif rtype == "software licence":
                gold = "department_head" if amount <= t2 else "cfo"
            elif rtype == "travel":
                gold = "team_lead" if amount <= t2 // 4 else "department_head"
            else:
                gold = "team_lead" if amount <= t1 else ("department_head" if amount <= t2 else "cfo")
        if gold != want:
            continue
        text = (f"Approval rules: purchases up to ${t1} can be approved by a team lead, up to ${t2} by a department head, "
                f"and anything above that by the CFO. Travel up to ${t2 // 4} can be approved by a team lead, above that "
                f"by a department head. Software licences up to ${t2} go to a department head, above that to the CFO. "
                f"Every contract, whatever its value, goes to the general counsel. A hire with an annual salary up to "
                f"${salary_cap} is approved by a department head, a higher salary by the HR director. "
                f"Who may approve this request?")
        return facts, text, gold
    raise RuntimeError("authority generator failed")


def authority(n: int, rng: random.Random) -> list:
    order = list(ROLES)
    out = []
    for i in range(n):
        facts, text, gold = gen_authority(rng, order[i % len(order)])
        opts = list(ROLES)
        rng.shuffle(opts)
        out.append(_item(f"rules7-authority-{i:04d}", "authority", "rules7:authority", facts,
                         {"approver": choice(text, {o: ROLES[o] for o in opts})}, {"approver": onehot(opts, gold)}))
    return out


# ===================================================================== fraud_points
FRAUD_RULES = [
    dict(key="account_age_days", kind="lt", ts=[7, 14, 30], lo=0, hi=900, step=1, ph="the account is less than {t} days old"),
    dict(key="billing_shipping_countries_differ", kind="bool", ph="the billing and shipping countries differ"),
    dict(key="order_total_usd", kind="ge", ts=[300, 500, 1000, 2000], lo=10, hi=4000, step=25, ph="the order total is at least ${t}"),
    dict(key="failed_payment_attempts", kind="ge", ts=[2, 3, 4], lo=0, hi=8, step=1, ph="there were at least {t} failed payment attempts"),
    dict(key="new_device", kind="bool", ph="the order comes from a device not seen before"),
    dict(key="vpn_or_proxy", kind="bool", ph="the connection uses a VPN or proxy"),
    dict(key="local_hour", kind="in", opts=[1, 2, 3, 4], other=[8, 9, 10, 12, 14, 16, 19, 21], ph="the order was placed between 01:00 and 04:59 local time"),
    dict(key="previous_chargebacks", kind="ge", ts=[1, 2], lo=0, hi=5, step=1, ph="the customer has at least {t} earlier chargebacks"),
    dict(key="disposable_email", kind="bool", ph="the email address is from a disposable-email provider"),
    dict(key="freight_forwarder_address", kind="bool", ph="the shipping address is a freight forwarder"),
]
LEVELS = ["low", "medium", "high", "critical"]


def gen_fraud(rng: random.Random, want: int):
    for _ in range(2000):
        specs = rng.sample(FRAUD_RULES, 6)
        rules = []
        for sp in specs:
            c = Cond({**sp, "phrase": sp["ph"]}, rng)
            rules.append((c, rng.choice([1, 2, 2, 3, 3, 4])))
        a = rng.choice([2, 3, 4])
        b = a + rng.choice([2, 3])
        d = b + rng.choice([2, 3])
        cut = (a, b, d)
        p = rng.choice([0.2, 0.35, 0.5, 0.7])
        facts = {c.key: c.sample(rng, rng.random() < p) for c, _ in rules}
        total = sum(pts for c, pts in rules if c.test(facts[c.key]))
        lvl = sum(total >= x for x in cut)
        if lvl != want:
            continue
        pts_txt = "; ".join(f"+{pts} if {c.phrase}" for c, pts in rules)
        text = (f"Fraud score: add up the points: {pts_txt}. Risk level: below {cut[0]} points is low, {cut[0]} to "
                f"{cut[1] - 1} is medium, {cut[1]} to {cut[2] - 1} is high, {cut[2]} or more is critical. "
                f"What risk level does this order get?")
        return rules, cut, facts, text, lvl
    raise RuntimeError("fraud generator failed")


def fraud_level(rules, cut, facts):
    total = sum(pts for c, pts in rules if c.key in facts and c.test(facts[c.key]))
    return sum(total >= x for x in cut)


def fraud_pivots(rules, cut, facts):
    """Facts whose removal leaves the level undecided (it differs with and without that rule's points)."""
    out = []
    for c, pts in rules:
        rest = sum(p for c2, p in rules if c2.key != c.key and c2.test(facts[c2.key]))
        if sum(rest >= x for x in cut) != sum(rest + pts >= x for x in cut):
            out.append(c.key)
    return out


def fraud_state(rng, facts):
    items = list(facts.items())
    rng.shuffle(items)
    return {"order_id": f"ORD-{rng.randint(10000, 99999)}", "customer": rng.choice(NAMES), **dict(items)}


def fraud_points(n: int, rng: random.Random) -> list:
    out = []
    for i in range(n):
        rules, cut, facts, text, lvl = gen_fraud(rng, i % 4)
        out.append(_item(f"rules7-fraud_points-{i:04d}", "fraud_points", "rules7:fraud_points", fraud_state(rng, facts),
                         {"risk": score_q(text, LEVELS)}, {"risk": {str(j): float(j == lvl) for j in range(4)}}))
    return out


# ===================================================================== missing facts
def missing_facts(pairs: int, rng: random.Random) -> list:
    out = []
    i = 0
    while i < pairs:  # admission
        node, state, facts, text = gen_admission(rng, i % 2 == 0)
        pv = pivots(node, facts)
        if not pv:
            continue
        gone = rng.choice(pv)
        gold = ev3(node, facts)
        full = _item(f"rules7-missing_facts-admission-{i:04d}-complete", "missing_facts", "missing:admission:complete",
                     state, {"admit": noul(text)}, {"admit": noul_target(gold)}, variant="complete", pair=i, task="admission")
        miss = {k: v for k, v in state.items() if k != gone}
        part = _item(f"rules7-missing_facts-admission-{i:04d}-missing", "missing_facts", "missing:admission:missing", miss,
                     {"admit": noul(text)}, {}, variant="missing", pair=i, task="admission", removed=gone)
        out += [full, part]
        i += 1
    i = 0
    while i < pairs:  # fraud points
        rules, cut, facts, text, lvl = gen_fraud(rng, i % 4)
        pv = fraud_pivots(rules, cut, facts)
        if not pv:
            continue
        gone = rng.choice(pv)
        state = fraud_state(rng, facts)
        full = _item(f"rules7-missing_facts-fraud_points-{i:04d}-complete", "missing_facts", "missing:fraud_points:complete",
                     state, {"risk": score_q(text, LEVELS)}, {"risk": {str(j): float(j == lvl) for j in range(4)}},
                     variant="complete", pair=i, task="fraud_points")
        part = _item(f"rules7-missing_facts-fraud_points-{i:04d}-missing", "missing_facts", "missing:fraud_points:missing",
                     {k: v for k, v in state.items() if k != gone}, {"risk": score_q(text, LEVELS)}, {},
                     variant="missing", pair=i, task="fraud_points", removed=gone)
        out += [full, part]
        i += 1
    return out


# ===================================================================== public sets
def _clean(t) -> str:
    return " ".join(str(t).split()) if t is not None else ""


def _norm(t) -> str:
    import re

    return re.sub(r"\W+", " ", str(t).lower()).strip()


def load_exclusions() -> dict:
    """Rule texts excluded from the ShARC selection (duplicated rule texts; normalised, first 200 chars): drop_keys.json,
    2 rule texts, 36 dev rows. Nothing is excluded from the patent phrases."""
    import os

    p = os.path.join(os.path.dirname(os.path.abspath(__file__)), "drop_keys.json")
    return {"sharc_drop": set(json.load(open(p))), "pairs": set(), "anchors": set()}


def sharc(n: int, rng: random.Random, pools: dict | None = None) -> tuple[list, dict]:
    """ShARC dev (CC BY-SA 3.0), the rows whose answer is yes or no (no follow-up question needed), balanced; at most
    eight utterances per rule text (the dev split has only 56 rule texts with yes / no answers)."""
    import pandas as pd
    from huggingface_hub import hf_hub_download

    repo, rev, f = SHARC
    df = pd.read_parquet(hf_hub_download(repo, f, repo_type="dataset", revision=rev))
    df = df[df.label.isin([0, 1])]
    rows = df.to_dict("records")
    dropped = 0
    if pools:  # rule texts listed in drop_keys.json are excluded (duplicated rule texts)
        bad = {}
        keep = []
        for r in rows:
            k = _norm(r["snippet"])[:200]
            if k not in bad:
                bad[k] = k in pools["sharc_drop"]
            if bad[k]:
                dropped += 1
            else:
                keep.append(r)
        rows = keep
    rng.shuffle(rows)
    per_tree, picked = {}, {True: [], False: []}
    for r in rows:
        yes = int(r["label"]) == 0
        if per_tree.get(r["tree_id"], 0) >= 8 or len(picked[yes]) >= n // 2:
            continue
        per_tree[r["tree_id"]] = per_tree.get(r["tree_id"], 0) + 1
        picked[yes].append(r)
    out = []
    for j, r in enumerate(sorted(picked[True] + picked[False], key=lambda r: r["utterance_id"])):
        state = {"rule text": _clean(r["snippet"]), "scenario": _clean(r["scenario"]) or "(none given)",
                 "conversation so far": _clean(r["history"]).replace(" Q:", "\nQ:").replace(" A:", "\nA:") or "(none)",
                 "user question": _clean(r["question"])}
        q = noul("Using only the rule text, the scenario and the conversation so far, do the rules say that the answer to "
                 "the user's question is yes?")
        out.append(_item(f"rules7-sharc-{r['utterance_id'][:12]}", "sharc", "sharc:dev", state, {"answer": q},
                         {"answer": noul_target(int(r["label"]) == 0)}, license="CC-BY-SA-3.0", split="public"))
    info = {"dataset": f"{SHARC[0]}@{SHARC[1]}", "file": SHARC[2], "dev_rows": int(len(pd.read_parquet(hf_hub_download(
        repo, f, repo_type="dataset", revision=rev)))), "yes_no_rows": int(len(df)),
            "excluded_rule_texts": dropped}
    return out, info


PATENT_LEVELS = ["not related (0)", "somewhat related (0.25)", "synonym with a different breadth, e.g. hypernym or "
                 "hyponym (0.5)", "close synonym (0.75)", "very close match (1.0)"]


def patent_phrases(n: int, rng: random.Random, pools: dict | None = None) -> tuple[list, dict]:
    """US Patent Phrase-to-Phrase Matching, the held-out (test) split of tasksource/patent-phrase-similarity with the
    expert scores 0 / 0.25 / 0.5 / 0.75 / 1; balanced over the five levels."""
    import pandas as pd
    from huggingface_hub import hf_hub_download

    repo, rev, f = PATENT
    df = pd.read_parquet(hf_hub_download(repo, f, repo_type="dataset", revision=rev))
    df = df.drop_duplicates(["anchor", "target", "context"])
    dropped = 0
    if pools:
        mask = [(_norm(a), _norm(t)) in pools["pairs"] or _norm(a) in pools["anchors"]
                for a, t in zip(df.anchor, df.target, strict=True)]
        dropped = int(sum(mask))
        df = df[[not m for m in mask]]
    by = {j: [r for r in df.to_dict("records") if abs(float(r["score"]) - j / 4) < 1e-6] for j in range(5)}
    out = []
    for j in range(5):
        rng.shuffle(by[j])
        for r in by[j][:n // 5]:
            state = {"phrase A": r["anchor"], "phrase B": r["target"], "technical field (CPC class)": r["context"]}
            q = score_q("In patent language, how similar in meaning is phrase B to phrase A, in the given technical "
                        "field?", PATENT_LEVELS)
            out.append(_item(f"rules7-patent-{hashlib.sha1((r['anchor'] + '|' + r['target'] + '|' + r['context']).encode()).hexdigest()[:12]}",
                             "patent_phrases", "patent_phrases:test", state, {"similarity": q},
                             {"similarity": {str(k): float(k == j) for k in range(5)}}, license="CC-BY-4.0",
                             split="public"))
    rng.shuffle(out)
    return out, {"dataset": f"{PATENT[0]}@{PATENT[1]}", "file": PATENT[2], "rows": int(len(df)),
                                                   "excluded_pairs": dropped}


# ===================================================================== build
def build(seed: int = 0, sizes: dict | None = None, public: bool = True, screen: bool = True) -> tuple[list, dict]:
    sz = {**SIZES, **(sizes or {})}
    items, info = [], {"version": VERSION, "seed": seed}
    items += admission(sz["admission"], random.Random(f"{seed}:admission"))
    items += rental(sz["rental"], random.Random(f"{seed}:rental"))
    items += agent_rules(sz["agent_rules"], random.Random(f"{seed}:agent"))
    items += authority(sz["authority"], random.Random(f"{seed}:authority"))
    items += fraud_points(sz["fraud_points"], random.Random(f"{seed}:fraud"))
    if public:
        pools = load_exclusions() if screen else None
        its, info["sharc"] = sharc(sz["sharc"], random.Random(f"{seed}:sharc"), pools)
        items += its
        its, info["patent"] = patent_phrases(sz["patent_phrases"], random.Random(f"{seed}:patent"), pools)
        items += its
    items += missing_facts(sz["missing_facts"], random.Random(f"{seed}:missing"))
    ids = set()
    for x in items:
        assert x["id"] not in ids, x["id"]
        ids.add(x["id"])
    info["counts"] = {s: sum(x["skill"] == s for x in items) for s in SKILLS}
    info["gold"] = {}
    for s in SKILLS:
        c = {}
        for x in items:
            if x["skill"] == s:
                for k, t in x["targets"].items():
                    g = max(t, key=t.get)
                    c[g] = c.get(g, 0) + 1
        info["gold"][s] = dict(sorted(c.items()))
    return items, info


def state_hashes(items: list) -> list:
    return sorted({hashlib.sha1(x["state"].encode()).hexdigest() for x in items})


def write(items: list, info: dict, outdir: str = ".") -> list:
    import os

    p = os.path.join(outdir, "rules7_v1_items.json.gz")
    with gzip.open(p, "wt") as fh:
        json.dump(items, fh, ensure_ascii=False)
    return [p]


if __name__ == "__main__":
    import argparse

    ap = argparse.ArgumentParser(description="build Rules7 v1 items")
    ap.add_argument("--seed", type=int, default=0)
    ap.add_argument("--out", default=".")
    a = ap.parse_args()
    its, inf = build(a.seed)
    print(json.dumps(inf, indent=1))
    print(write(its, inf, a.out))