Download sample/tasks/inspect/score.py from zero-trust-physics/zero-trust-physics-sample-group-1: direct link, hf CLI and curl.
- Browser
- Download file 62.9 kB
-
https://huggingface.co/datasets/zero-trust-physics/zero-trust-physics-sample-group-1/resolve/main/sample/tasks/inspect/score.py
- Command line
-
hf download hf://datasets/zero-trust-physics/zero-trust-physics-sample-group-1/sample/tasks/inspect/score.py
-
curl -L -o score.py https://huggingface.co/datasets/zero-trust-physics/zero-trust-physics-sample-group-1/resolve/main/sample/tasks/inspect/score.py
62.9 kB
"""Score replies to the multi-step environments with no judge: a program and the verifier.
python3 score.py REPLIES --engine ENGINE [--environments F] [--only id,id] [--out F]
[--calls-from reply|harness] [--harness-dir DIR]
REPLIES is a folder with one file per environment, <id>.txt, the whole text of a reply.
--calls-from harness the call record is the harness's own: <id>.harness.jsonl, written by
harness/mcp_log_proxy.py outside the solver's working directory (in
--harness-dir, default REPLIES). A <id>.calls.jsonl beside the reply,
when there is one, is read only to catch an edit: it must equal the
harness log call for call.
--calls-from reply (the earlier set's way) the call record is <id>.calls.jsonl beside the reply:
one JSON object a line, {"tool": "<name>", "arguments": {...}}.
ENGINE is the verifier: the path to mcp_stdio (MCP over stdio, no network), or an MCP address
beginning http. A task is scored only on the engine it was built on: the verifier's version must
be the task's reference.gateway_version (engine_tag), and a local binary's SHA-256 the task's
reference.engine_binary_sha256.
The answer card is one JSON object on the reply's last line. Its shape is the family's:
tradeoff, chain_design (kind design_to_limit, chained_design)
{"passing": DESIGN, "failing": DESIGN, "binding": "<constraint id>"}
DESIGN = {"run": {"request": R, "proof": "<run_seal>"},
"solve": {"request": R, "proof": "<solution_seal>"}} (solve only where the task has one)
Where a constraint is that the run completes and it binds, the failing DESIGN also carries
"stopped": "<the stop's name>" and "step": <steps_landed>. R = {"tool": ..., "arguments": {...}}
The design shapes, one scorer for every group (check.design says which):
run a run alone.
coupled check.design.chain names a solver and coupling: the run, then a solve handed that sealed run.
continued check.design.chain.kind "continuation", or chain.layout.kind "continue": the run, then a run of
the same card that continues it through from, starting from its sealed final state,
DESIGN = {"run": {...}, "next": {"request": R, "proof": "<run_seal>"}}. The next run's template
is chain.next_template, chain.template or chain.next; its start fields are chain.carried
({field: where the first run's answer holds it}), chain.handed (with chain.handed_from) or
chain.carry and chain.clock, each equal to the first run's answer bit for bit. A constraint on
"next" reads the next run, and a stop constraint judges it.
solve check.design.tool or check.design.kind "solve": DESIGN = {"solve": {...}}, one solve and no
run. A binding refusal is named ("stopped") with no step.
staged check.design.stages: DESIGN = {"<stage key>": {"request": R, "proof": ...}, ...}, one entry per
stage in order; a later stage carries an earlier stage's answer at a named input (handed) or
continues an earlier run (continues), bit for bit.
A constraint's read may carry "index": one entry of an output the verifier returns as a list.
budget (kind budgeted_search)
{"holds": {"request": R, "proof": "<seal>"},
"stops": {"request": R, "proof": "<seal>", "stopped": "<stop name>"}}
forensics
{"false_rows": {"<row>": "<reason>", ...}} ({} when every row is genuine)
Every proof is verified on the verifier (verify_tape for a run_seal, verify_solution for a
solution_seal, short form) and every number judged is read from the verifier's own answer to the
card's request, sent again here, never from the reply.
Scores per environment
----------------------
reward 0 or 1, exactly as the earlier scorer: 1 only when correct and proofs_hold are both 1.
proofs_hold: every proof on the card verifies. correct: the card is the right answer and
nothing below under "integrity" failed.
graded in [0, 1], beside reward.
Integrity (graded 0 and reward 0, whatever the answer): the card cannot be read; a proof does not
verify (a copied, nudged, edited or stale proof); a request differs from the task's template other
than at the design variable; a chained solve not handed its own design's sealed run; no call log;
a call log beside the reply that differs from the harness log; a harness log whose chain breaks;
a forbidden tool called; more computing calls than the budget; a request on the card that is not
among the calls; a forensics answer with no computing call behind it; a task built on another
engine than the verifier.
tradeoff, chain_design, budget. With integrity held, the sides are judged on the verifier: the
passing design meets every constraint and the failing one breaks the named binding constraint
(budget: holds completes, stops ends with the task's stop, named on the card), on the side the
task asks for, inside its range, with any stop and step the card must name. Wrong sides score 0.
With the sides right:
e = the length of the smallest interval holding both designs' values and the reference
boundary (for a bracket that straddles the boundary, its width)
tol = the task's tolerance (tradeoff, chain_design) or relative width x |boundary| (budget)
r = e / tol
graded = 1 when reward is 1 (r <= 1 and the bracket straddles it)
= 0.5 ** log10(r) when r > 1: each tenfold of looseness halves the score
(r 1.35 -> 0.914, 2 -> 0.811, 10 -> 0.5, 100 -> 0.25)
= 0.5 when r <= 1 but the bracket misses the reference boundary
by more than the slack (another crossing than the one asked)
The decay is smooth and falls monotonically with r, and a near miss scores near the top.
forensics. With integrity held, graded is F1 over the (row, reason) pairs: a row counts as found
only with its right reason. precision = found / named, recall = found / false rows; an empty
answer to a table with no false row scores 1. A card that names every row of the table false is
a blanket answer and scores 0, as do unknown rows and reasons outside the task's list.
Licence: Apache-2.0.
"""
import argparse
import copy
import hashlib
import json
import math
import os
import re
import sys
HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, HERE)
from ztp_mcp import McpError, StdioVerifier, Verifier # noqa: E402
FAMILIES = ("tradeoff", "chain_design", "budget", "forensics")
KINDS = {"tradeoff": "design_to_limit", "chain_design": "chained_design", "budget": "budgeted_search", "forensics": "forensics"}
NOT_STOPPED = ("completed", "converged")
PREFIX_ENDS = ("__", ".", ":", "/")
VERIFIER_TOOLS = ("list_cards", "list_solvers", "find_model", "describe_card", "describe_solver", "cite",
"run_trajectory", "compute_step", "verify_step", "design_run", "solve", "run_dataset",
"validate_series", "verify_tape", "verify_solution", "verify_dataset", "verify_receipt", "find_flip")
# Calls that read the catalogue compute nothing and are free in a call budget.
FREE_TOOLS = ("list_cards", "list_solvers", "find_model", "describe_card", "describe_solver", "cite", "verify_receipt")
REASONS = ("value_altered", "seal_wrong", "flag_omitted", "retired_model", "stop_hidden")
GRADED_DECAY = 0.5 # graded = GRADED_DECAY ** log10(r)
OTHER_CROSSING = 0.5 # right sides, tight, around another crossing than the reference boundary
class Integrity(Exception):
"""The answer cannot be trusted: graded 0 and reward 0."""
class Wrong(Exception):
"""The answer is trusted and wrong: graded 0 and reward 0."""
def load_environments(path):
with open(path, encoding="utf-8") as f:
return [json.loads(line) for line in f if line.strip()]
def row_problems(env):
"""What a task row lacks against the shared row contract (empty when none)."""
out = []
for key in ("id", "family", "models", "real_thing", "task", "check", "seed", "reference"):
if key not in env:
out.append("no %s" % key)
family = env.get("family")
if family not in FAMILIES:
out.append("family %r" % family)
elif "kind" in env and env["kind"] != KINDS[family]:
out.append("kind %r for family %s (want %s)" % (env["kind"], family, KINDS[family]))
ref = env.get("reference") or {}
for key in ("engine_tag", "engine_commit", "engine_binary_sha256"):
if not ref.get(key):
out.append("reference.%s missing" % key)
return out
def file_sha256(path):
h = hashlib.sha256()
with open(path, "rb") as f:
for block in iter(lambda: f.read(1 << 20), b""):
h.update(block)
return h.hexdigest()
def open_verifier(engine):
if engine.startswith("http://") or engine.startswith("https://"):
verifier = Verifier(engine, pause_s=0.5)
verifier.binary_sha256 = None
else:
if not os.path.isfile(engine):
sys.exit("no file at %s: give the path to mcp_stdio, or an MCP address beginning http" % engine)
verifier = StdioVerifier([engine])
verifier.binary_sha256 = file_sha256(engine)
try:
verifier.connect()
except McpError as problem:
sys.exit("the verifier failed, so nothing was scored: %s" % problem)
if not isinstance(verifier.server, dict) or not verifier.server.get("name"):
close_verifier(verifier)
sys.exit("the verifier failed, so nothing was scored: %s did not answer as an MCP server" % engine)
return verifier
def close_verifier(verifier):
if hasattr(verifier, "close"):
verifier.close()
# ------------------------------------------------------------------------------------------
# reading the reply and the call logs
# ------------------------------------------------------------------------------------------
def _no_constant(name):
raise ValueError("%s is not a number" % name)
def read_card(reply):
"""(card, problem): the JSON object on the reply's last line. A closing code fence is passed over."""
lines = [line.strip() for line in (reply or "").replace("\r", "\n").split("\n") if line.strip()]
while lines and lines[-1].startswith("```"):
lines.pop()
if not lines:
return None, "the reply is empty"
try:
card = json.loads(lines[-1], parse_constant=_no_constant)
except ValueError:
return None, "the last line is not one JSON object"
if not isinstance(card, dict):
return None, "the last line is not one JSON object"
return card, None
def tool_name(name):
"""The verifier's own name for a tool an agent's program may have prefixed (mcp__zerotrust__solve)."""
if not isinstance(name, str):
return None
if name in VERIFIER_TOOLS:
return name
for tool in VERIFIER_TOOLS:
for joint in PREFIX_ENDS:
if name.endswith(joint + tool):
return tool
return name
def without_readout(arguments):
"""A run's arguments as sealed: a readout is not part of a run's seal."""
if not isinstance(arguments, dict):
return arguments
return {k: v for k, v in arguments.items() if k != "readout"}
def numbers_by_value(value):
"""Every number as a float, so 18 and 18.0 (one request to the engine) compare equal; bools kept."""
if isinstance(value, dict):
return {k: numbers_by_value(v) for k, v in value.items()}
if isinstance(value, list):
return [numbers_by_value(v) for v in value]
if isinstance(value, int) and not isinstance(value, bool):
return float(value)
return value
def canonical(arguments):
"""A request's arguments as compared with the call log: no readout, keys sorted, numbers by value."""
return json.dumps(numbers_by_value(without_readout(arguments)), sort_keys=True, separators=(",", ":"))
def _arguments(one):
arguments = one.get("arguments")
if isinstance(arguments, str):
try:
arguments = json.loads(arguments)
except ValueError:
arguments = {}
return arguments if isinstance(arguments, dict) else {}
def read_calls(path):
"""Every call in a reply-side call log, [(tool, arguments)], or None when there is no log."""
if not path or not os.path.isfile(path):
return None
calls = []
with open(path, encoding="utf-8", errors="replace") as f:
for line in f:
line = line.strip()
if not line:
continue
try:
one = json.loads(line)
except ValueError:
continue
if isinstance(one, dict):
calls.append((tool_name(one.get("tool")), _arguments(one)))
return calls
def chain_of(previous, entry):
payload = json.dumps(entry, sort_keys=True, separators=(",", ":"))
return hashlib.sha384(((previous or "") + payload).encode("utf-8")).hexdigest()
def read_harness_log(path):
"""(calls, problem) from a log written by harness/mcp_log_proxy.py. calls is None when there is no log;
problem names the first line whose chain does not follow (an edit, a line taken out or put in)."""
if not path or not os.path.isfile(path):
return None, None
calls, previous = [], None
with open(path, encoding="utf-8", errors="replace") as f:
for number_, line in enumerate(f, 1):
if not line.strip():
continue
try:
entry = json.loads(line)
except ValueError:
return calls, "line %d of the harness log is not JSON" % number_
if not isinstance(entry, dict) or "chain" not in entry:
return calls, "line %d of the harness log carries no chain" % number_
chain = entry.pop("chain")
if chain != chain_of(previous, entry) or entry.get("seq") != len(calls) + 1:
return calls, "the harness log's chain breaks at line %d" % number_
previous = chain
calls.append((tool_name(entry.get("tool")), _arguments(entry)))
return calls, None
def write_harness_log(path, calls):
"""A chained log in the proxy's format, for tests and the cheat suite: calls [(tool, arguments)]."""
previous = None
with open(path, "w", encoding="utf-8") as f:
for seq, (tool, arguments) in enumerate(calls, 1):
entry = {"seq": seq, "jsonrpc_id": seq, "tool": tool, "arguments": arguments, "ts_request": None,
"ts_response": None, "duration_s": None, "response_sha384": None, "text_sha384": None, "is_error": False}
entry["chain"] = chain_of(previous, entry)
previous = entry["chain"]
f.write(json.dumps(entry, sort_keys=True) + "\n")
# ------------------------------------------------------------------------------------------
# the verifier, asked again
# ------------------------------------------------------------------------------------------
def stop_name_in(sentence):
names = re.findall(r"\(([A-Z][A-Za-z0-9]*[a-z][A-Za-z0-9]*)\)", sentence or "")
return names[-1] if names else None
class Replay:
"""The verifier, with every answer remembered: the same request is sent once."""
def __init__(self, verifier):
self.verifier = verifier
self.seen = {}
server = getattr(verifier, "server", None) or {}
self.version = server.get("version")
self.binary_sha256 = getattr(verifier, "binary_sha256", None)
def call(self, tool, arguments):
key = tool + "\x00" + json.dumps(arguments, sort_keys=True)
if key not in self.seen:
try:
self.seen[key] = self.verifier.call_json(tool, arguments)
except McpError as problem:
if not str(problem).startswith("protocol error"):
raise SystemExit("the verifier failed, so nothing was scored: %s" % problem)
self.seen[key] = ("the verifier did not take the request: %s" % problem, True)
return self.seen[key]
def answer(self, tool, arguments, readout=None):
"""One run or solve computed again: {"stopped", "outcome", "stop", "proof", "body"}."""
arguments = copy.deepcopy(without_readout(arguments))
if readout is not None and tool == "run_trajectory":
arguments["readout"] = readout
body, is_error = self.call(tool, arguments)
if is_error or not isinstance(body, dict):
sentence = body if isinstance(body, str) else json.dumps(body)
return {"stopped": True, "outcome": "stopped before computing", "stop": stop_name_in(sentence),
"proof": None, "body": None, "sentence": sentence}
outcome = body.get("outcome")
stopped = outcome not in NOT_STOPPED
return {"stopped": stopped, "outcome": outcome, "stop": body.get("reject") if stopped else None,
"proof": body.get("run_seal") or body.get("solution_seal"), "body": body,
"sentence": body.get("reject_detail")}
def proof_holds(self, tool, arguments, proof):
"""(holds, words): the card's seal verified by verify_tape or verify_solution, short form."""
if not isinstance(proof, str) or not re.fullmatch(r"[0-9a-f]{96}", proof):
return False, "the proof is not a SHA-384 seal of 96 hex digits"
if tool == "run_trajectory":
body, is_error = self.call("verify_tape", {"request": without_readout(arguments), "run_seal": proof})
elif tool == "solve":
body, is_error = self.call("verify_solution", {"request": arguments, "solution_seal": proof})
else:
return False, "a proof is verified for run_trajectory or solve only, not %s" % tool
if is_error or not isinstance(body, dict):
return False, "the verifier would not verify it: %s" % (str(body)[:200])
if body.get("holds") is True:
return True, None
return False, "the verifier says the seal does not hold (cause %s)" % body.get("cause")
def engine_problem(env, replay):
"""None when the verifier is the engine the task was built on; else what differs."""
ref = env.get("reference") or {}
tag = ref.get("gateway_version") or (ref.get("engine_tag") or "").lstrip("v")
if not tag:
return "the task names no engine it was built on"
if (ref.get("engine_tag") or "v" + tag).lstrip("v") != tag:
return "the task's engine_tag %s and gateway_version %s disagree" % (ref.get("engine_tag"), ref.get("gateway_version"))
if replay.version != tag:
return "the task was built on engine %s; the verifier is %s" % (tag, replay.version)
want = ref.get("engine_binary_sha256")
if replay.binary_sha256 and want and replay.binary_sha256 != want:
return "the verifier's binary is not the one the task was built on (sha256 %s..., want %s...)" % (replay.binary_sha256[:12], want[:12])
return None
# ------------------------------------------------------------------------------------------
# requests and their inputs
# ------------------------------------------------------------------------------------------
_PART = re.compile(r"([A-Za-z_0-9]+)((?:\[\d+\])*)")
def get_path(obj, path):
here = obj
for part in path.split("."):
found = _PART.fullmatch(part)
if not found or not isinstance(here, dict) or found.group(1) not in here:
return None
here = here[found.group(1)]
for index in re.findall(r"\[(\d+)\]", found.group(2)):
if not isinstance(here, list) or int(index) >= len(here):
return None
here = here[int(index)]
return here
def set_path(obj, path, value):
parts = path.split(".")
here = obj
for i, part in enumerate(parts):
m = _PART.fullmatch(part)
name, idx = m.group(1), [int(k) for k in re.findall(r"\[(\d+)\]", m.group(2))]
last = i == len(parts) - 1
if not idx:
if last:
here[name] = value
else:
here = here[name]
else:
here = here[name]
for j, k in enumerate(idx):
if last and j == len(idx) - 1:
here[k] = value
else:
here = here[k]
def number(value):
return isinstance(value, (int, float)) and not isinstance(value, bool) and math.isfinite(value)
def differs(template, given, free, where=""):
"""The first place where a request differs from the task's, other than the free places. None when none."""
if where in free:
return None
if isinstance(template, dict):
if not isinstance(given, dict):
return where or "the request"
for key in set(template) | set(given):
place = "%s.%s" % (where, key) if where else key
if place in free:
continue
if key not in given or key not in template:
return place
found = differs(template[key], given[key], free, place)
if found:
return found
return None
if isinstance(template, list):
if not isinstance(given, list) or len(given) != len(template):
return where
for index, (a, b) in enumerate(zip(template, given)):
found = differs(a, b, free, "%s[%d]" % (where, index))
if found:
return found
return None
if number(template) and number(given):
return None if float(template) == float(given) else where
return None if template == given else where
def design_value(variable, run_arguments, solve_arguments, next_arguments=None):
"""The design variable of one design, read from its requests (on: run, solve, or next, a continued run)."""
kind = variable["kind"]
if kind == "path":
on = variable.get("on", "run")
source = {"solve": solve_arguments, "next": next_arguments}.get(on, run_arguments) or {}
value = get_path(source, variable["path"])
for place in variable.get("also") or []:
again = get_path(source, place)
if not (number(again) and number(value) and float(again) == float(value)):
return None
return float(value) if number(value) else None
if kind == "entry_angle_deg":
radial = get_path(run_arguments or {}, "initial.radial_speed_m_s")
transverse = get_path(run_arguments or {}, "initial.transverse_speed_m_s")
if not (number(radial) and number(transverse)) or transverse <= 0:
return None
speed = math.hypot(radial, transverse)
if abs(speed - variable["speed_m_s"]) > 1e-6 * variable["speed_m_s"]:
return None
return math.degrees(math.atan2(-radial, transverse))
return None
def variable_places(variable):
if variable["kind"] == "entry_angle_deg":
return {"initial.radial_speed_m_s", "initial.transverse_speed_m_s"}
if variable["kind"] == "path" and variable.get("on", "run") == "run":
return {variable["path"]} | set(variable.get("also") or [])
return set()
def read_value(read, answer):
"""One number from a replayed answer: final, result, or the extreme of a run's readout."""
body = answer["body"]
if body is None:
return None
kind = read["kind"]
value = None
if kind == "final":
value = (body.get("final_state") or {}).get(read["quantity"])
elif kind == "result":
value = (body.get("result") or {}).get(read["quantity"])
elif kind == "flag_extent":
# an advisory flag the run raised, at its largest extent; 0 when the run does not raise it
value = max([x.get("extent") or 0.0 for x in body.get("exceedance_extremes") or []
if isinstance(x, dict) and x.get("flag") == read["quantity"]] or [0.0])
elif kind == "extreme":
for quantity in (body.get("readout") or {}).get("quantities") or []:
if quantity.get("quantity") == read["quantity"]:
value = quantity.get(read["which"])
if "index" in read:
# one entry of an output the verifier returns as a list (a hose's modes, a solve asked at several points)
k = read["index"]
value = value[k] if isinstance(value, list) and isinstance(k, int) and -len(value) <= k < len(value) else None
return value if number(value) else None
def readout_for(constraints, on="run"):
"""The readout a run is sent with: the extremes its constraints read (on: run, next, or a stage key)."""
quantities = sorted({c["read"]["quantity"] for c in constraints if c["on"] == on and c["read"]["kind"] == "extreme"})
return {"quantities": quantities} if quantities else None
def design_shape(spec):
"""Which of the design shapes a task's check.design is: run, coupled, continued, solve or staged."""
if spec.get("stages"):
return "staged"
if spec.get("tool") == "solve" or spec.get("kind") == "solve":
return "solve"
chain = spec.get("chain") or {}
if chain.get("kind") == "continuation" or (chain.get("layout") or {}).get("kind") == "continue":
return "continued"
return "coupled" if chain else "run"
def continuation_of(spec):
"""A continued design's chain in one form: (next template, {start field: where the first run's answer holds it},
next outcomes, the next run's places that also hold a first-run design value)."""
chain = spec["chain"]
template = chain.get("next_template") or chain.get("template") or chain.get("next")
if "carried" in chain: # group 1
carried = dict(chain["carried"])
elif "handed" in chain: # group 4
named = chain.get("handed_from") or {}
carried = {k: "final_state." + named.get(k, k) for k in chain["handed"]}
else: # group 5
carried = {k: "final_state." + k for k in chain.get("carry") or []}
if chain.get("clock"):
carried[chain["clock"]["field"]] = "final_state." + chain["clock"]["from"]
outcomes = chain.get("next_outcomes") or spec["run_outcomes"]
return template, carried, outcomes, list(chain.get("next_also") or [])
def meets(constraint, value):
if value is None:
return False
return value <= constraint["limit"] if constraint["op"] == "<=" else value >= constraint["limit"]
def history_layout_problem(layout, parameters, frames_count):
"""None when the arrays of a chained solve are laid out as the task states; else what is not."""
if layout is None:
return None
if layout["kind"] == "stardust_slab":
names = ("history_time_s", "history_pressure_pa", "history_heat_transfer_coefficient_kg_per_m2_s",
"history_flow_enthalpy_j_per_kg", "history_radiative_heating_w_per_m2")
columns = [parameters.get(name) for name in names]
if not all(isinstance(c, list) and all(number(v) for v in c) for c in columns):
return "the history columns are not all lists of numbers"
time, pressure, coefficient, enthalpy, radiative = columns
rows = frames_count + 3
if any(len(c) != rows for c in columns):
return "the history has not one row before the %d frames handed and two after them" % frames_count
if time[0] != 0.0 or coefficient[0] != 0.0:
return "row 0 is not at 0 s with no heating"
if pressure[0] != pressure[1] or enthalpy[0] != enthalpy[1]:
return "row 0 does not repeat the first frame's pressure and enthalpy"
if abs(time[-2] - (time[-3] + 1.0)) > 1e-9 or time[-1] != layout["cool_to_s"]:
return "the rows after the frames are not at 1 s after the last frame and at %g s" % layout["cool_to_s"]
if coefficient[-2] != 0.0 or coefficient[-1] != 0.0:
return "the stream is not off after the frames"
if pressure[-1] != pressure[-3] or pressure[-2] != pressure[-3] or enthalpy[-1] != enthalpy[-3] or enthalpy[-2] != enthalpy[-3]:
return "the rows after the frames do not hold the last frame's pressure and enthalpy"
if any(v != 0.0 for v in radiative):
return "a row of the history holds radiative heating"
return None
if layout["kind"] == "triga_element":
return None # every array is handed by the coupling and held to its bits by the verifier
return "an unknown layout"
# ------------------------------------------------------------------------------------------
# the call record
# ------------------------------------------------------------------------------------------
def card_requests(env, card):
"""Every request on the card, [(tool, arguments)], read leniently (for the call log)."""
out = []
def take(part):
if isinstance(part, dict) and isinstance(part.get("request"), dict) and isinstance(part["request"].get("arguments"), dict):
out.append((tool_name(part["request"].get("tool")), part["request"]["arguments"]))
if env["family"] in ("tradeoff", "chain_design"):
stages = [s["key"] for s in (env["check"].get("design") or {}).get("stages") or []]
for side in ("passing", "failing"):
design = card.get(side) if isinstance(card.get(side), dict) else {}
for key in stages or ("run", "solve", "next"):
take(design.get(key))
elif env["family"] == "budget":
take(card.get("holds"))
take(card.get("stops"))
return out
def sequence(calls):
return [(tool_name(t), json.dumps(numbers_by_value(a), sort_keys=True)) for t, a in calls]
def call_record_problem(env, card, calls, reply_calls, calls_from, log_problem, row):
"""None when the call record holds; else why not (an integrity failure)."""
check = env["check"]
if calls_from == "harness":
if calls is None:
return "no harness call log: every attempt is scored with the calls the harness recorded"
if log_problem:
return log_problem
if reply_calls is not None and sequence(reply_calls) != sequence(calls):
return "the call log beside the reply differs from the harness log"
elif calls is None:
return "no call log: every environment is scored with the agent's calls"
calls = [(tool_name(t), a) for t, a in calls]
banned = sorted({t for t, _ in calls if t in (check.get("forbidden") or [])})
if banned:
return "the log holds calls of %s, which the task rules out" % ", ".join(banned)
computing = [(t, a) for t, a in calls if t not in FREE_TOOLS]
row["computing_calls"] = len(computing)
if check.get("budget") and len(computing) > check["budget"]:
return "%d computing calls; the budget is %d" % (len(computing), check["budget"])
sent = {(t, canonical(a)) for t, a in computing}
for tool, arguments in card_requests(env, card):
if (tool, canonical(arguments)) not in sent:
return "a %s request on the card is not among the calls in the log" % tool
if env["family"] == "forensics" and not computing:
return "no computing call behind the answer: the table was not put to the verifier"
return None
# ------------------------------------------------------------------------------------------
# the families
# ------------------------------------------------------------------------------------------
def request_of(part, tool, what):
"""The arguments of one request on the card (Integrity when it is not one)."""
if not isinstance(part, dict):
raise Integrity("%s is missing" % what)
request = part.get("request")
if not (isinstance(request, dict) and isinstance(request.get("arguments"), dict)):
raise Integrity("%s has no request {\"tool\": ..., \"arguments\": {...}}" % what)
if tool_name(request.get("tool")) != tool:
raise Integrity("%s is a request of %s, not %s" % (what, request.get("tool"), tool))
return request["arguments"]
def score_design(env, design, which, replay, proofs):
"""One design of a boundary family: facts {x, met, values, stopped, steps_landed}."""
check = env["check"]
spec = check["design"]
shape = design_shape(spec)
if shape in ("solve", "staged", "continued") and not isinstance(design, dict):
raise Integrity("the %s design is missing" % which)
if shape == "solve":
return score_solve_design(env, design, which, replay, proofs)
if shape == "staged":
return score_staged_design(env, design, which, replay, proofs)
if shape == "continued":
return score_continued_design(env, design, which, replay, proofs)
chain = spec.get("chain")
run_args = request_of((design or {}).get("run") if isinstance(design, dict) else None, "run_trajectory",
"the %s design's run" % which)
free = set(spec.get("free") or []) | variable_places(spec["variable"])
where = differs(spec["template"], without_readout(run_args), free)
if where:
raise Integrity("the %s design's run differs from the task's at %s" % (which, where))
for place in spec.get("free") or []:
if place.endswith(".steps"):
steps = get_path(run_args, place)
if not (isinstance(steps, int) and not isinstance(steps, bool) and 1 <= steps <= spec.get("most_steps", 10 ** 7)):
raise Integrity("the %s design's run has no whole number of steps at %s" % (which, place))
run_proof = design["run"].get("proof")
holds, words = replay.proof_holds("run_trajectory", run_args, run_proof)
proofs.append(holds)
if not holds:
raise Integrity("the %s design's run_seal: %s" % (which, words))
run = replay.answer("run_trajectory", run_args, readout_for(check["constraints"]))
stop_names = [c["stop"] for c in check["constraints"] if c["on"] == "outcome"]
stopped_by_name = run["outcome"] == "refused" and run["stop"] in stop_names
if run["outcome"] not in spec["run_outcomes"] and not stopped_by_name:
raise Wrong("the %s design's run comes back %s%s, not %s" % (
which, run["outcome"], " (%s)" % run["stop"] if run["stop"] else "", " or ".join(spec["run_outcomes"])))
solve_args, solve = None, None
if chain:
solve_args = request_of(design.get("solve"), "solve", "the %s design's solve" % which)
if solve_args.get("solver") != chain["solver"]:
raise Integrity("the %s design's solve is of %s, not the task's solver" % (which, solve_args.get("solver")))
handed = solve_args.get("from")
if not isinstance(handed, dict) or handed.get("coupling") != chain["coupling"]:
raise Integrity("the %s design's solve is not handed its run through the coupling %s" % (which, chain["coupling"]))
if canonical(handed.get("request")) != canonical(run_args) or handed.get("run_seal") != run_proof:
raise Integrity("the %s design's solve is not handed the design's own sealed run" % which)
parameters = solve_args.get("parameters")
if not isinstance(parameters, dict):
raise Integrity("the %s design's solve has no parameters" % which)
solve_free = set(chain.get("handed") or [])
if spec["variable"]["kind"] == "path" and spec["variable"].get("on") == "solve":
solve_free.add(spec["variable"]["path"].split(".", 1)[1])
where = differs(chain["parameters"], parameters, solve_free)
if where:
raise Integrity("the %s design's solve differs from the task's at parameters.%s" % (which, where))
frames = len((run["body"] or {}).get("frames") or [])
problem = history_layout_problem(chain.get("layout"), parameters, frames)
if problem:
raise Integrity("the %s design's solve: %s" % (which, problem))
holds, words = replay.proof_holds("solve", solve_args, design["solve"].get("proof"))
proofs.append(holds)
if not holds:
raise Integrity("the %s design's solution_seal: %s" % (which, words))
solve = replay.answer("solve", solve_args)
if solve["outcome"] != "converged":
raise Wrong("the %s design's solve comes back %s%s, not converged" % (
which, solve["outcome"], " (%s)" % solve["stop"] if solve["stop"] else ""))
x = design_value(spec["variable"], run_args, solve_args)
if x is None:
raise Integrity("the %s design's value of the design variable cannot be read (%s)" % (which, spec["variable"].get("words", "")))
met, values = {}, {}
for constraint in check["constraints"]:
if constraint["on"] == "outcome":
values[constraint["id"]] = run["outcome"] if not run["stop"] else "%s (%s)" % (run["outcome"], run["stop"])
met[constraint["id"]] = not (run["outcome"] == "refused" and run["stop"] == constraint["stop"])
continue
value = read_value(constraint["read"], run if constraint["on"] == "run" else solve)
values[constraint["id"]] = value
met[constraint["id"]] = meets(constraint, value)
facts = {"x": x, "met": met, "values": values}
if run["outcome"] not in NOT_STOPPED and run["body"]:
facts["stopped"], facts["steps_landed"] = run["stop"], run["body"].get("steps_landed")
return facts
def halted(answer, stop, staged=False):
"""True when an answer is stopped by the stop named: a refusal ("refused"); for a staged design, any outcome that
is not completed or converged (group 3's rule, kept as built)."""
if staged:
return answer["outcome"] not in NOT_STOPPED and answer["stop"] == stop
return answer["outcome"] == "refused" and answer["stop"] == stop
def constraint_facts(check, answers, judged, staged=False):
"""met and values of every constraint: each read from the answer its "on" names (answers: {on: answer}); a stop
constraint ("on": "outcome") is judged on the answer judged, or on its stage's answer for a staged design."""
met, values = {}, {}
for c in check["constraints"]:
if c["on"] == "outcome":
a = answers.get(c["stage"]) if c.get("stage") else judged
values[c["id"]] = None if a is None else (a["outcome"] if not a["stop"] else "%s (%s)" % (a["outcome"], a["stop"]))
met[c["id"]] = a is not None and not halted(a, c["stop"], staged)
continue
a = answers.get(c["on"])
value = read_value(c["read"], a) if a is not None else None
values[c["id"]] = value
met[c["id"]] = meets(c, value) if c.get("limit") is not None else None
return met, values
def stopped_by(answer, constraints, stage=None):
"""True when an answer is stopped by a stop one of the task's stop constraints names (for the stage given)."""
return any(halted(answer, c["stop"], stage is not None) for c in constraints
if c["on"] == "outcome" and (stage is None or c.get("stage") == stage))
def score_solve_design(env, design, which, replay, proofs):
"""One design that is one solve and no run (check.design.tool or kind "solve")."""
check = env["check"]
spec = check["design"]
var = spec["variable"]
solve_args = request_of(design.get("solve"), "solve", "the %s design's solve" % which)
if solve_args.get("solver") != spec["template"].get("solver"):
raise Integrity("the %s design's solve is of %s, not the task's solver" % (which, solve_args.get("solver")))
free = set(spec.get("free") or []) | {var["path"]} | set(var.get("also") or [])
where = differs(spec["template"], solve_args, free)
if where:
raise Integrity("the %s design's solve differs from the task's at %s" % (which, where))
holds, words = replay.proof_holds("solve", solve_args, design["solve"].get("proof"))
proofs.append(holds)
if not holds:
raise Integrity("the %s design's solution_seal: %s" % (which, words))
solve = replay.answer("solve", solve_args)
if solve["outcome"] not in spec["run_outcomes"] and not stopped_by(solve, check["constraints"]):
raise Wrong("the %s design's solve comes back %s%s, not %s" % (
which, solve["outcome"], " (%s)" % solve["stop"] if solve["stop"] else "", " or ".join(spec["run_outcomes"])))
x = design_value(dict(var, on="solve"), None, solve_args)
if x is None:
raise Integrity("the %s design's value of the design variable cannot be read (%s)" % (which, var.get("words", "")))
met, values = constraint_facts(check, {"solve": solve}, solve)
facts = {"x": x, "met": met, "values": values}
if solve["outcome"] not in NOT_STOPPED and solve["body"]:
facts["stopped"], facts["steps_landed"], facts["no_step"] = solve["stop"], None, True
return facts
def score_continued_design(env, design, which, replay, proofs):
"""One design of a run and the run that continues it through from. The verifier holds the hand-off: it computes
the first run again, compares its seal and refuses a start that is not the first run's final state; the scorer
also holds each carried start field to the first run's answer, bit for bit."""
check = env["check"]
spec = check["design"]
var = spec["variable"]
on_next = var["kind"] == "path" and var.get("on") == "next"
template, carried, next_outcomes, next_also = continuation_of(spec)
run_args = request_of(design.get("run"), "run_trajectory", "the %s design's run" % which)
free = set(spec.get("free") or []) | (set() if on_next else variable_places(var))
where = differs(spec["template"], without_readout(run_args), free)
if where:
raise Integrity("the %s design's run differs from the task's at %s" % (which, where))
run_proof = design["run"].get("proof")
holds, words = replay.proof_holds("run_trajectory", run_args, run_proof)
proofs.append(holds)
if not holds:
raise Integrity("the %s design's run_seal: %s" % (which, words))
run = replay.answer("run_trajectory", run_args, readout_for(check["constraints"], "run"))
if run["outcome"] not in spec["run_outcomes"]:
raise Wrong("the %s design's first run comes back %s%s, not %s" % (
which, run["outcome"], " (%s)" % run["stop"] if run["stop"] else "", " or ".join(spec["run_outcomes"])))
next_args = request_of(design.get("next"), "run_trajectory", "the %s design's next run" % which)
handed = next_args.get("from")
if (not isinstance(handed, dict) or canonical(handed.get("request")) != canonical(run_args)
or handed.get("run_seal") != run_proof):
raise Integrity("the %s design's next run does not continue the design's own sealed run (from)" % which)
next_free = {"initial." + name for name in carried} | {"from"} | set(next_also)
if on_next:
next_free |= {var["path"]} | set(var.get("also") or [])
where = differs(template, without_readout(next_args), next_free)
if where:
raise Integrity("the %s design's next run differs from the task's at %s" % (which, where))
start = next_args.get("initial") if isinstance(next_args.get("initial"), dict) else {}
for name, source in carried.items():
held, given = get_path(run["body"] or {}, source), start.get(name)
if name not in start or not (given == held or (number(given) and number(held) and float(given) == float(held))):
raise Integrity("the %s design's next run does not start from its run's %s, bit for bit" % (which, source))
holds, words = replay.proof_holds("run_trajectory", next_args, design["next"].get("proof"))
proofs.append(holds)
if not holds:
raise Integrity("the %s design's next run_seal: %s" % (which, words))
nxt = replay.answer("run_trajectory", next_args, readout_for(check["constraints"], "next"))
if nxt["outcome"] not in next_outcomes and not stopped_by(nxt, check["constraints"]):
raise Wrong("the %s design's next run comes back %s%s, not %s" % (
which, nxt["outcome"], " (%s)" % nxt["stop"] if nxt["stop"] else "", " or ".join(next_outcomes)))
x = design_value(var, run_args, None, next_args)
if x is None:
raise Integrity("the %s design's value of the design variable cannot be read (%s)" % (which, var.get("words", "")))
for place in next_also:
again = get_path(next_args, place)
if not (number(again) and float(again) == float(x)):
raise Integrity("the %s design's next run does not hold the design value at %s" % (which, place))
met, values = constraint_facts(check, {"run": run, "next": nxt}, nxt)
facts = {"x": x, "met": met, "values": values}
if nxt["outcome"] not in NOT_STOPPED and nxt["body"]:
facts["stopped"], facts["steps_landed"] = nxt["stop"], nxt["body"].get("steps_landed")
return facts
def build_stage_request(spec, stage, x, answers, requests):
"""One stage's request of a staged design at x: the template, x at the variable's places, the values handed from
earlier stages' answers, and a continuation's start and from (used by run_reference.py)."""
q = copy.deepcopy(stage["template"])
var = spec["variable"]
if var.get("stage") == stage["key"]:
for place in [var["path"]] + list(var.get("also") or []):
set_path(q, place, x)
for h in stage.get("handed") or []:
set_path(q, h["to"], read_value(h["read"], answers[h["from"]]))
if stage.get("continues"):
parent = stage["continues"]
final = answers[parent]["body"]["final_state"]
q["initial"] = {k: final[k] for k in stage["template"]["initial"]}
q["from"] = {"request": copy.deepcopy(requests[parent]), "run_seal": answers[parent]["proof"]}
return q
def score_staged_design(env, design, which, replay, proofs):
"""One staged design (check.design.stages): each stage a run or a solve, in order."""
check = env["check"]
spec = check["design"]
var = spec["variable"]
stages = spec["stages"]
answers, requests, facts = {}, {}, {}
for i, stage in enumerate(stages):
key, tool = stage["key"], stage["tool"]
sent = without_readout(request_of(design.get(key), tool, "the %s design's %s" % (which, key)))
free = set(stage.get("free") or []) | {h["to"] for h in stage.get("handed") or []}
if var.get("stage") == key:
free |= {var["path"]} | set(var.get("also") or [])
if stage.get("continues"):
free |= {"initial", "from"}
where = differs(stage["template"], sent, free)
if where:
raise Integrity("the %s design's %s differs from the task's at %s" % (which, key, where))
for h in stage.get("handed") or []:
want = read_value(h["read"], answers[h["from"]])
got = get_path(sent, h["to"])
if want is None or not number(got) or float(got) != float(want):
raise Integrity("the %s design's %s does not carry %s's %s at %s, bit for bit" % (
which, key, h["from"], h["read"]["quantity"], h["to"]))
if stage.get("continues"):
parent = stage["continues"]
handed = sent.get("from")
if (not isinstance(handed, dict) or canonical(handed.get("request")) != canonical(requests[parent])
or handed.get("run_seal") != design[parent].get("proof")):
raise Integrity("the %s design's %s does not continue the design's own sealed %s run (from)" % (which, key, parent))
final = (answers[parent]["body"] or {}).get("final_state") or {}
start = sent.get("initial")
keys = set(stage["template"]["initial"])
if not isinstance(start, dict) or set(start) != keys or any(
not number(start[k]) or float(start[k]) != final.get(k) for k in keys):
raise Integrity("the %s design's %s does not start from the final state of its %s run, bit for bit" % (which, key, parent))
holds, words = replay.proof_holds(tool, sent, design[key].get("proof"))
proofs.append(holds)
if not holds:
raise Integrity("the %s design's %s proof: %s" % (which, key, words))
answer = replay.answer(tool, sent, readout_for(check["constraints"], key) if tool == "run_trajectory" else None)
named = stopped_by(answer, check["constraints"], stage=key)
if answer["outcome"] not in stage["outcomes"] and not named:
raise Wrong("the %s design's %s comes back %s%s, not %s" % (
which, key, answer["outcome"], " (%s)" % answer["stop"] if answer["stop"] else "", " or ".join(stage["outcomes"])))
answers[key], requests[key] = answer, sent
if named:
facts["stopped"], facts["stopped_stage"] = answer["stop"], key
facts["steps_landed"] = (answer["body"] or {}).get("steps_landed") if tool == "run_trajectory" else None
facts["no_step"] = tool != "run_trajectory"
if i != len(stages) - 1:
raise Wrong("the %s design's %s stops (%s) before its last stage" % (which, key, answer["stop"]))
x = design_value(dict(var, on="run"), requests.get(var["stage"]), None)
if x is None:
raise Integrity("the %s design's value of the design variable cannot be read (%s)" % (which, var.get("words", "")))
met, values = constraint_facts(check, answers, None, staged=True)
facts.update({"x": x, "met": met, "values": values})
return facts
def grade_bracket(a, b, star, tol, slack, row):
"""(reward_ok, graded) for a bracket [a, b] with its sides right."""
width = abs(b - a)
straddles = min(a, b) - slack <= star <= max(a, b) + slack
within = width <= tol * (1 + 1e-9)
e = max(a, b, star) - min(a, b, star)
r = e / tol if tol > 0 else float("inf")
row["width"], row["width_ratio"] = width, r
if within and straddles:
return True, 1.0
if r <= 1:
return False, OTHER_CROSSING
return False, GRADED_DECAY ** math.log10(r)
def score_boundary(env, card, replay, row, proofs):
check, reference = env["check"], env["reference"]
passing = score_design(env, card.get("passing"), "passing", replay, proofs)
failing = score_design(env, card.get("failing"), "failing", replay, proofs)
row["passing"], row["failing"] = passing, failing
span = check["design"].get("range")
if span and not all(span[0] <= x <= span[1] for x in (passing["x"], failing["x"])):
raise Wrong("a design lies outside the range the task states, %g to %g" % tuple(span))
broken = [c for c, ok in passing["met"].items() if not ok]
if broken:
raise Wrong("the passing design breaks %s" % ", ".join(broken))
broken = [c for c, ok in failing["met"].items() if not ok]
if not broken:
raise Wrong("the failing design meets every constraint")
binding = card.get("binding")
if binding != reference["binding"]:
raise Wrong("binding names %r; the constraint that binds is another" % (binding,))
if binding not in broken:
raise Wrong("the failing design does not break %s, the constraint named binding" % binding)
if binding in [c["id"] for c in check["constraints"] if c["on"] == "outcome"]:
said = card.get("failing") or {}
if said.get("stopped") != failing.get("stopped"):
raise Wrong("the failing design's run stops with %s; the card says %r" % (failing.get("stopped"), said.get("stopped")))
if failing.get("no_step"):
pass # a solve that is refused has no step: its stop's name is stated
elif not (isinstance(said.get("step"), int) and not isinstance(said.get("step"), bool) and said["step"] == failing.get("steps_landed")):
raise Wrong("the failing design's run is sealed to step %s; the card says %r" % (failing.get("steps_landed"), said.get("step")))
spec = check["design"]
xp, xf = passing["x"], failing["x"]
if spec["direction"] == "largest" and not xf > xp:
raise Wrong("the task asks for the largest value that holds: the failing design must lie above the passing one")
if spec["direction"] == "smallest" and not xf < xp:
raise Wrong("the task asks for the smallest value that holds: the failing design must lie below the passing one")
ok, graded = grade_bracket(xp, xf, reference["boundary"], spec["tolerance"], spec["tolerance"] * 0.5, row)
if not ok:
return graded, "the two designs are %.6g apart; the task asks for %.6g or less, and they must straddle the boundary" % (
abs(xf - xp), spec["tolerance"])
return 1.0, None
def score_budget(env, card, replay, row, proofs):
check, reference = env["check"], env["reference"]
template, path, tool = check["template"], check["variable"], check["tool"]
sides = {}
for side in ("holds", "stops"):
arguments = request_of(card.get(side), tool, side)
also = check.get("also") or []
where = differs(template, without_readout(arguments), {path} | set(also))
if where:
raise Integrity("the %s request differs from the task's at %s" % (side, where))
x = get_path(arguments, path)
if not number(x):
raise Integrity("the %s request has no number at %s" % (side, path))
for place in also:
again = get_path(arguments, place)
if not (number(again) and float(again) == float(x)):
raise Integrity("the %s request does not hold the same value at %s as at %s" % (side, place, path))
holds, words = replay.proof_holds(tool, arguments, card[side].get("proof"))
proofs.append(holds)
sides[side] = (float(x), arguments, holds, words)
for side in ("holds", "stops"):
if not sides[side][2]:
raise Integrity("the %s seal: %s" % (side, sides[side][3]))
held = replay.answer(tool, sides["holds"][1])
stopped = replay.answer(tool, sides["stops"][1])
row["holds_outcome"], row["stops_outcome"] = held["outcome"], "%s (%s)" % (stopped["outcome"], stopped["stop"])
if held["outcome"] not in NOT_STOPPED:
raise Wrong("the holds request comes back %s (%s)" % (held["outcome"], held["stop"]))
if stopped["stop"] != check["stop"]:
raise Wrong("the stops request comes back %s (%s), not the stop %s" % (stopped["outcome"], stopped["stop"], check["stop"]))
if card["stops"].get("stopped") != check["stop"]:
raise Wrong("the card names the stop %r; the verifier names %s" % (card["stops"].get("stopped"), check["stop"]))
xh, xs = sides["holds"][0], sides["stops"][0]
star = reference["boundary"]
row["holds_value"], row["stops_value"] = xh, xs
tol = check["relative_width"] * abs(star)
ok, graded = grade_bracket(xh, xs, star, tol, 1e-9 * abs(star), row)
if not ok:
return graded, "the bracket is %.6g wide; the task asks for %.3g of the value or less, and it must hold the stop" % (
abs(xs - xh), check["relative_width"])
return 1.0, None
def forensics_f1(env, named):
"""(graded, problem): F1 over (row, reason) pairs; problem when the card is not a usable answer."""
if not isinstance(named, dict):
return 0.0, "false_rows is not an object of row and reason"
rows = [c["row"] for c in env["check"]["rows"]]
truth = env["reference"]["false_rows"]
unknown = [r for r in named if r not in set(rows)]
if unknown:
return 0.0, "no rows %s in the table" % ", ".join(sorted(unknown))
reasons = env["check"].get("reasons") or REASONS
bad = [r for r, why in named.items() if why not in reasons]
if bad:
return 0.0, "the reason for %s is not one of %s" % (", ".join(sorted(bad)), ", ".join(reasons))
if rows and set(named) == set(rows):
return 0.0, "every row of the table is named false: a blanket answer"
found = sum(1 for r, why in named.items() if truth.get(r) == why)
if not truth and not named:
return 1.0, None
precision = found / len(named) if named else 0.0
recall = found / len(truth) if truth else 0.0
f1 = 2 * precision * recall / (precision + recall) if precision + recall else 0.0
if f1 >= 1.0:
return 1.0, None
missed = sorted(set(truth) - set(named))
wrongly = sorted(set(named) - set(truth))
wrong_reason = sorted(r for r in set(truth) & set(named) if truth[r] != named[r])
said = []
if missed:
said.append("%d false row(s) not named" % len(missed))
if wrongly:
said.append("%d genuine row(s) named false" % len(wrongly))
if wrong_reason:
said.append("%d false row(s) with another reason" % len(wrong_reason))
return f1, "; ".join(said)
def score(env, reply, replay, calls=None, reply_calls=None, calls_from="reply", log_problem=None):
"""One environment scored. calls: the authoritative record [(tool, arguments)] (None: no record);
reply_calls: the reply-side log, compared with calls under calls_from="harness"."""
row = {"id": env["id"], "family": env["family"], "kind": KINDS.get(env["family"]), "calls_from": calls_from,
"correct": 0, "proofs_hold": 0, "reward": 0, "graded": 0.0, "verdict": None, "reason": None}
card, problem = read_card(reply)
if problem:
row.update(verdict="no_card", reason=problem)
return row
proofs = []
try:
problem = engine_problem(env, replay)
if problem:
raise Integrity(problem)
problem = call_record_problem(env, card, calls, reply_calls, calls_from, log_problem, row)
if problem:
raise Integrity(problem)
family = env["family"]
if family in ("tradeoff", "chain_design"):
graded, reason = score_boundary(env, card, replay, row, proofs)
elif family == "budget":
graded, reason = score_budget(env, card, replay, row, proofs)
elif family == "forensics":
named = card.get("false_rows")
if isinstance(named, dict):
row["named"] = named
graded, reason = forensics_f1(env, named)
proofs = [True]
if reason and graded == 0.0 and not isinstance(named, dict):
raise Wrong(reason)
else:
raise Wrong("unknown family %s" % family)
except Integrity as problem:
row.update(verdict="integrity", reason=str(problem), proofs_hold=int(bool(proofs) and all(proofs)))
return row
except Wrong as problem:
row.update(verdict="wrong", reason=str(problem), proofs_hold=int(bool(proofs) and all(proofs)))
return row
proofs_hold = int(bool(proofs) and all(proofs))
correct = int(graded >= 1.0 and reason is None)
row.update(correct=correct, proofs_hold=proofs_hold, reward=int(correct == 1 and proofs_hold == 1),
graded=round(graded, 6) if proofs_hold else 0.0,
verdict="pass" if correct and proofs_hold else ("near" if graded > 0 else "wrong"), reason=reason)
return row
def records_for(folder, env_id, calls_from, harness_dir=None):
"""(calls, reply_calls, log_problem) for one environment's reply in folder."""
reply_calls = read_calls(os.path.join(folder, env_id + ".calls.jsonl"))
if calls_from == "harness":
calls, log_problem = read_harness_log(os.path.join(harness_dir or folder, env_id + ".harness.jsonl"))
return calls, reply_calls, log_problem
return reply_calls, None, None
def main():
parser = argparse.ArgumentParser(description=__doc__.split("\n")[0])
parser.add_argument("replies")
parser.add_argument("--engine", required=True)
parser.add_argument("--only")
parser.add_argument("--environments", required=True)
parser.add_argument("--out")
parser.add_argument("--calls-from", choices=("reply", "harness"), default="harness")
parser.add_argument("--harness-dir")
parser.add_argument("--quiet", action="store_true")
args = parser.parse_args()
environments = load_environments(args.environments)
if args.only:
wanted = set(args.only.split(","))
environments = [e for e in environments if e["id"] in wanted]
missing = wanted - {e["id"] for e in environments}
if missing:
sys.exit("no environments %s in %s" % (", ".join(sorted(missing)), args.environments))
for env in environments:
for problem in row_problems(env):
print("warning: %s: %s" % (env.get("id"), problem), file=sys.stderr)
verifier = open_verifier(args.engine)
replay = Replay(verifier)
rows = []
try:
for env in environments:
path = os.path.join(args.replies, env["id"] + ".txt")
reply = open(path, encoding="utf-8", errors="replace").read() if os.path.isfile(path) else ""
calls, reply_calls, log_problem = records_for(args.replies, env["id"], args.calls_from, args.harness_dir)
row = score(env, reply, replay, calls, reply_calls, args.calls_from, log_problem)
rows.append(row)
if not args.quiet:
print("%-58s reward %d graded %.4f %-9s %s" % (env["id"], row["reward"], row["graded"], row["verdict"],
row["reason"] or ""), flush=True)
replay.seen.clear()
finally:
close_verifier(verifier)
if args.out:
with open(args.out, "w", encoding="utf-8") as f:
for row in rows:
f.write(json.dumps(row) + "\n")
total = len(rows)
print("\n%d environments: reward %d, graded %.4f (mean %.4f), correct %d, proofs_hold %d" % (
total, sum(r["reward"] for r in rows), sum(r["graded"] for r in rows),
sum(r["graded"] for r in rows) / total if total else 0.0,
sum(r["correct"] for r in rows), sum(r["proofs_hold"] for r in rows)))
by = {}
for r in rows:
by.setdefault(r["family"], []).append(r)
for family in FAMILIES:
if family in by:
print(" %-13s reward %d of %d, mean graded %.4f" % (family, sum(r["reward"] for r in by[family]), len(by[family]),
sum(r["graded"] for r in by[family]) / len(by[family])))
if __name__ == "__main__":
main()
"""Score replies to the multi-step environments with no judge: a program and the verifier.
python3 score.py REPLIES --engine ENGINE [--environments F] [--only id,id] [--out F]
[--calls-from reply|harness] [--harness-dir DIR]
REPLIES is a folder with one file per environment, <id>.txt, the whole text of a reply.
--calls-from harness the call record is the harness's own: <id>.harness.jsonl, written by
harness/mcp_log_proxy.py outside the solver's working directory (in
--harness-dir, default REPLIES). A <id>.calls.jsonl beside the reply,
when there is one, is read only to catch an edit: it must equal the
harness log call for call.
--calls-from reply (the earlier set's way) the call record is <id>.calls.jsonl beside the reply:
one JSON object a line, {"tool": "<name>", "arguments": {...}}.
ENGINE is the verifier: the path to mcp_stdio (MCP over stdio, no network), or an MCP address
beginning http. A task is scored only on the engine it was built on: the verifier's version must
be the task's reference.gateway_version (engine_tag), and a local binary's SHA-256 the task's
reference.engine_binary_sha256.
The answer card is one JSON object on the reply's last line. Its shape is the family's:
tradeoff, chain_design (kind design_to_limit, chained_design)
{"passing": DESIGN, "failing": DESIGN, "binding": "<constraint id>"}
DESIGN = {"run": {"request": R, "proof": "<run_seal>"},
"solve": {"request": R, "proof": "<solution_seal>"}} (solve only where the task has one)
Where a constraint is that the run completes and it binds, the failing DESIGN also carries
"stopped": "<the stop's name>" and "step": <steps_landed>. R = {"tool": ..., "arguments": {...}}
The design shapes, one scorer for every group (check.design says which):
run a run alone.
coupled check.design.chain names a solver and coupling: the run, then a solve handed that sealed run.
continued check.design.chain.kind "continuation", or chain.layout.kind "continue": the run, then a run of
the same card that continues it through from, starting from its sealed final state,
DESIGN = {"run": {...}, "next": {"request": R, "proof": "<run_seal>"}}. The next run's template
is chain.next_template, chain.template or chain.next; its start fields are chain.carried
({field: where the first run's answer holds it}), chain.handed (with chain.handed_from) or
chain.carry and chain.clock, each equal to the first run's answer bit for bit. A constraint on
"next" reads the next run, and a stop constraint judges it.
solve check.design.tool or check.design.kind "solve": DESIGN = {"solve": {...}}, one solve and no
run. A binding refusal is named ("stopped") with no step.
staged check.design.stages: DESIGN = {"<stage key>": {"request": R, "proof": ...}, ...}, one entry per
stage in order; a later stage carries an earlier stage's answer at a named input (handed) or
continues an earlier run (continues), bit for bit.
A constraint's read may carry "index": one entry of an output the verifier returns as a list.
budget (kind budgeted_search)
{"holds": {"request": R, "proof": "<seal>"},
"stops": {"request": R, "proof": "<seal>", "stopped": "<stop name>"}}
forensics
{"false_rows": {"<row>": "<reason>", ...}} ({} when every row is genuine)
Every proof is verified on the verifier (verify_tape for a run_seal, verify_solution for a
solution_seal, short form) and every number judged is read from the verifier's own answer to the
card's request, sent again here, never from the reply.
Scores per environment
----------------------
reward 0 or 1, exactly as the earlier scorer: 1 only when correct and proofs_hold are both 1.
proofs_hold: every proof on the card verifies. correct: the card is the right answer and
nothing below under "integrity" failed.
graded in [0, 1], beside reward.
Integrity (graded 0 and reward 0, whatever the answer): the card cannot be read; a proof does not
verify (a copied, nudged, edited or stale proof); a request differs from the task's template other
than at the design variable; a chained solve not handed its own design's sealed run; no call log;
a call log beside the reply that differs from the harness log; a harness log whose chain breaks;
a forbidden tool called; more computing calls than the budget; a request on the card that is not
among the calls; a forensics answer with no computing call behind it; a task built on another
engine than the verifier.
tradeoff, chain_design, budget. With integrity held, the sides are judged on the verifier: the
passing design meets every constraint and the failing one breaks the named binding constraint
(budget: holds completes, stops ends with the task's stop, named on the card), on the side the
task asks for, inside its range, with any stop and step the card must name. Wrong sides score 0.
With the sides right:
e = the length of the smallest interval holding both designs' values and the reference
boundary (for a bracket that straddles the boundary, its width)
tol = the task's tolerance (tradeoff, chain_design) or relative width x |boundary| (budget)
r = e / tol
graded = 1 when reward is 1 (r <= 1 and the bracket straddles it)
= 0.5 ** log10(r) when r > 1: each tenfold of looseness halves the score
(r 1.35 -> 0.914, 2 -> 0.811, 10 -> 0.5, 100 -> 0.25)
= 0.5 when r <= 1 but the bracket misses the reference boundary
by more than the slack (another crossing than the one asked)
The decay is smooth and falls monotonically with r, and a near miss scores near the top.
forensics. With integrity held, graded is F1 over the (row, reason) pairs: a row counts as found
only with its right reason. precision = found / named, recall = found / false rows; an empty
answer to a table with no false row scores 1. A card that names every row of the table false is
a blanket answer and scores 0, as do unknown rows and reasons outside the task's list.
Licence: Apache-2.0.
"""
import argparse
import copy
import hashlib
import json
import math
import os
import re