| """Target-blind legal-output grammars for the admitted Level-2 benchmark.""" |
|
|
| from __future__ import annotations |
|
|
| import itertools |
| import json |
| import re |
|
|
|
|
| PROFILES = frozenset({"none", "domain_legal_v1", "countdown_legal_v3"}) |
|
|
|
|
| def countdown_legal_regex(reference: str) -> str: |
| """Enumerate operand-exact expression syntax without consulting the target.""" |
|
|
| numbers = tuple(str(int(value)) for value in json.loads(reference)["numbers"]) |
| operator = r"[+*/-]" |
|
|
| def trees(values: tuple[str, ...]) -> tuple[str, ...]: |
| if len(values) == 1: |
| return (re.escape(values[0]),) |
| expressions = [] |
| for split in range(1, len(values)): |
| for left in trees(values[:split]): |
| for right in trees(values[split:]): |
| expressions.append(r"\(" + left + " " + operator + " " + right + r"\)") |
| return tuple(expressions) |
|
|
| expressions = set() |
| for values in set(itertools.permutations(numbers)): |
| expressions.update(trees(values)) |
| return r"\\boxed\{(?:" + "|".join(sorted(expressions)) + r")\}" |
|
|
|
|
| def legal_regex(profile: str, domain: str, reference: str) -> str | None: |
| """Return the frozen legal syntax for one row; never inspect its target.""" |
|
|
| if profile not in PROFILES: |
| raise ValueError(f"unknown ModeBench syntax profile: {profile}") |
| if profile == "none": |
| return None |
| if profile == "countdown_legal_v3": |
| if domain != "countdown": |
| raise ValueError("countdown_legal_v3 is Countdown-only") |
| return countdown_legal_regex(reference) |
| if domain == "pantry_plan": |
| spec = json.loads(reference) |
| alternatives = [] |
| for ingredient in spec["ingredients"]: |
| identifier = str(ingredient["id"]) |
| minimum = int(ingredient["min_if_used_g"]) |
| available = int(ingredient["available_g"]) |
| step = int(ingredient["step_g"]) |
| alternatives.extend( |
| f"{identifier}={grams}" |
| for grams in range(minimum, available + 1, step) |
| ) |
| atom = "(?:" + "|".join(re.escape(value) for value in alternatives) + ")" |
| return r"\\boxed\{" + atom + "(?:;" + atom + r"){1,3}\}" |
| fixed = { |
| "python_factors": r"\\boxed\{lambda n: [A-Za-z0-9 _%<>=!+*/().-]+\}", |
| "mathir": r"\\boxed\{[A-F](?:;[A-F]){0,3}\}", |
| } |
| if domain not in fixed: |
| raise ValueError(f"domain_legal_v1 has no grammar for {domain}") |
| return fixed[domain] |
|
|
|
|
| def guided_sampling_params(base, profile: str, domain: str, references: list[str]): |
| """Copy one vLLM parameter object per row and attach its legal grammar.""" |
|
|
| if profile == "none": |
| return base |
| import copy |
| from vllm.sampling_params import GuidedDecodingParams |
|
|
| params = [] |
| for reference in references: |
| row = copy.copy(base) |
| regex = legal_regex(profile, domain, str(reference)) |
| if regex is None: |
| raise RuntimeError("active syntax profile resolved no grammar") |
| row.guided_decoding = GuidedDecodingParams(regex=regex) |
| params.append(row) |
| return params |
|
|
