Datasets:

ExpertCrowd
/

ec-swe

#!/usr/bin/env python3
"""Is "break the grader's fixture and collect the weight" a strategy?
    python3 faultprobe.py
One question, asked over every tree that has ever been graded with this grader
(.calib/mutation-probe.json and the current-schema rows of .calib/calibration.json):
    for each criterion this tree does not pass, what does the tree GAIN by
    turning that criterion from a FAIL into a GRADER FAULT?
An agent can do that without touching the criterion it is failing: the oracle is
compiled against the tree and driven through its exported API, so a tree that
renames an exported symbol, or that hangs inside one scenario, converts a
criterion it would fail into one the grader cannot judge.
That is the channel. Three rules are compared:
    absolve    the shipped rule: a faulted criterion is scored 1.0
    normalise  §5.3 as literally written: scored 0.0 and struck from the
               denominator, the reward renormalised over the weight measured
    strike     what is implemented: scored 0.0, struck from the blocker set,
               nothing renormalised. The normalised figure is reported in the
               info block, and the run is flagged isError for a re-run.
A rule closes the channel iff no tree can gain under it. Anything above zero is
weight an agent can have for breaking the grader instead of meeting a criterion.
"""

from __future__ import annotations

import json
from pathlib import Path

import mutprobe as M

HERE = Path(__file__).resolve().parent
CALIB = HERE / ".calib"


def load_matrix() -> dict[str, dict[str, bool]]:
    """Every recorded tree whose row uses the criterion names in force today."""
    graders, _cap = M.load_table()
    known = {n for n, _w, _b in graders}
    # A row is usable as long as it covers every criterion of the board in
    # force today; an older schema is skipped rather than half-read.
    core = set(known)
    rows: dict[str, dict[str, bool]] = {}
    for path in (CALIB / "mutation-probe.json", CALIB / "calibration.json"):
        if not path.exists():
            continue
        try:
            entries = json.loads(path.read_text())
        except (ValueError, OSError):
            continue
        for e in entries:
            res = e.get("results") or {}
            if not core.issubset(res):
                continue  # an older schema, or a partial run
            rows[e["tree"]] = {n: bool(res.get(n)) for n in known}
    return rows


# ─── the three rules ───────────────────────────────────────────────────────


def absolve(results, graders, cap, faults):
    """Shipped: a faulted criterion is scored 1.0 and cannot cap."""
    faults = set(faults)
    uncapped = sum(w for n, w, _b in graders if results.get(n) or n in faults)
    failed = [n for n, _w, b in graders if b and n not in faults and not results.get(n)]
    return uncapped if not failed else max(0.0, min(uncapped, cap))


def normalise(results, graders, cap, faults):
    """§5.3 literally: scored 0.0, and out of the denominator too."""
    faults = set(faults)
    measured = sum(w for n, w, _b in graders if n not in faults)
    if measured <= 0:
        return 0.0
    earned = sum(w for n, w, _b in graders if n not in faults and results.get(n))
    failed = [n for n, _w, b in graders if b and n not in faults and not results.get(n)]
    score = earned / measured
    return score if not failed else max(0.0, min(score, cap))


def strike_no_ceiling(results, graders, cap, faults):
    """Scored 0.0 and struck from the blocker set, without the unproven ceiling.
    The intermediate step, kept because it is the one that looks right and is
    not: striking a faulted BLOCKER also lifts the cap, and lifting the cap is
    worth the whole gap between it and 1.00 to a tree that would fail a gate.
    """
    faults = set(faults)
    uncapped = sum(w for n, w, _b in graders if n not in faults and results.get(n))
    failed = [n for n, _w, b in graders if b and n not in faults and not results.get(n)]
    return uncapped if not failed else max(0.0, min(uncapped, cap))


def strike(results, graders, cap, faults):
    """Implemented: scored 0.0, not renormalised, unproven blockers keep the cap."""
    return M.reward(results, graders, cap, faults)[0]


RULES = (("absolve", absolve), ("normalise", normalise),
         ("no-ceiling", strike_no_ceiling), ("strike", strike))


def main() -> None:
    graders, cap = M.load_table()
    names = [n for n, _w, _b in graders]
    weights = {n: w for n, w, _b in graders}
    rows = load_matrix()
    if not rows:
        raise SystemExit("no recorded rows use today's criterion names")

    print(f"{len(rows)} recorded trees, {len(names)} criteria, cap {cap:.2f}")
    print("gain = what the tree scores once one criterion it FAILS is turned "
          "into a fault, minus what it scores honestly\n")

    worst = {label: (-9.9, "", "") for label, _fn in RULES}
    print(f"{'tree':<28} {'criterion it breaks':<46} {'honest':>7} "
          + " ".join(f"{label:>10}" for label, _fn in RULES))
    for tree in sorted(rows):
        results = rows[tree]
        honest = M.reward(results, graders, cap)[0]
        for c in names:
            if results.get(c):
                continue  # it passes this one; breaking it can only cost
            line = f"{tree:<28} {c + f' (w={weights[c]:.2f})':<46} {honest:>7.3f}"
            for label, fn in RULES:
                got = fn(results, graders, cap, {c})
                gain = got - honest
                line += f" {got:>6.3f}{gain:+.3f}"
                if gain > worst[label][0]:
                    worst[label] = (gain, tree, c)
            print(line)

    print("\n=== the most a tree can gain by breaking one fixture ===")
    for label, _fn in RULES:
        gain, tree, c = worst[label]
        verdict = "CHANNEL OPEN" if gain > 1e-9 else "closed"
        print(f"  {label:<10} {gain:+.3f}  ({tree}, {c})  -> {verdict}")

    # ─── the proof, as opposed to the illustration ─────────────────────────
    #
    # The rows above are the trees that happen to have been graded. The channel
    # is a property of the arithmetic, not of the sample, so: every one of the
    # 2^n outcome vectors a tree could possibly have, against every non-empty
    # subset of criteria it could turn into a fault. A rule is closed iff the
    # largest gain over the whole space is zero.
    print(f"\n=== every possible tree ({1 << len(names)} outcome vectors) x every "
          f"subset of faults ({(1 << len(names)) - 1}) ===")
    worst_all = {label: (-9.9, (), ()) for label, _fn in RULES}
    for outcome in range(1 << len(names)):
        results = {n: bool(outcome >> i & 1) for i, n in enumerate(names)}
        honest = M.reward(results, graders, cap)[0]
        for mask in range(1, 1 << len(names)):
            faults = {names[i] for i in range(len(names)) if mask >> i & 1}
            for label, fn in RULES:
                gain = fn(results, graders, cap, faults) - honest
                if gain > worst_all[label][0]:
                    reds = tuple(n for n in names if not results[n])
                    worst_all[label] = (gain, reds, tuple(sorted(faults)))
    for label, _fn in RULES:
        gain, reds, faults = worst_all[label]
        verdict = "CHANNEL OPEN" if gain > 1e-9 else "CLOSED"
        print(f"  {label:<11} max gain {gain:+.3f}  -> {verdict}")
        if gain > 1e-9:
            print(f"      worst case: a tree failing {list(reds) or 'nothing'}")
            print(f"      breaks      {list(faults)}")

    strike_gain = worst_all["strike"][0]
    print("\n" + ("PASS: under the implemented rule, breaking any set of fixtures "
                  "is never worth anything."
                  if strike_gain <= 1e-9 else
                  f"FAIL: the implemented rule still pays {strike_gain:+.3f}."))
    return 0 if strike_gain <= 1e-9 else 1


if __name__ == "__main__":
    raise SystemExit(main())

	#!/usr/bin/env python3
	"""Is "break the grader's fixture and collect the weight" a strategy?

	python3 faultprobe.py

	One question, asked over every tree that has ever been graded with this grader
	(.calib/mutation-probe.json and the current-schema rows of .calib/calibration.json):

	for each criterion this tree does not pass, what does the tree GAIN by
	turning that criterion from a FAIL into a GRADER FAULT?

	An agent can do that without touching the criterion it is failing: the oracle is
	compiled against the tree and driven through its exported API, so a tree that
	renames an exported symbol, or that hangs inside one scenario, converts a
	criterion it would fail into one the grader cannot judge.
	That is the channel. Three rules are compared:

	absolve the shipped rule: a faulted criterion is scored 1.0
	normalise §5.3 as literally written: scored 0.0 and struck from the
	denominator, the reward renormalised over the weight measured
	strike what is implemented: scored 0.0, struck from the blocker set,
	nothing renormalised. The normalised figure is reported in the
	info block, and the run is flagged isError for a re-run.

	A rule closes the channel iff no tree can gain under it. Anything above zero is
	weight an agent can have for breaking the grader instead of meeting a criterion.
	"""

	from __future__ import annotations

	import json
	from pathlib import Path

	import mutprobe as M

	HERE = Path(__file__).resolve().parent
	CALIB = HERE / ".calib"


	def load_matrix() -> dict[str, dict[str, bool]]:
	"""Every recorded tree whose row uses the criterion names in force today."""
	graders, _cap = M.load_table()
	known = {n for n, _w, _b in graders}
	# A row is usable as long as it covers every criterion of the board in
	# force today; an older schema is skipped rather than half-read.
	core = set(known)
	rows: dict[str, dict[str, bool]] = {}
	for path in (CALIB / "mutation-probe.json", CALIB / "calibration.json"):
	if not path.exists():
	continue
	try:
	entries = json.loads(path.read_text())
	except (ValueError, OSError):
	continue
	for e in entries:
	res = e.get("results") or {}
	if not core.issubset(res):
	continue # an older schema, or a partial run
	rows[e["tree"]] = {n: bool(res.get(n)) for n in known}
	return rows


	# ─── the three rules ───────────────────────────────────────────────────────


	def absolve(results, graders, cap, faults):
	"""Shipped: a faulted criterion is scored 1.0 and cannot cap."""
	faults = set(faults)
	uncapped = sum(w for n, w, _b in graders if results.get(n) or n in faults)
	failed = [n for n, _w, b in graders if b and n not in faults and not results.get(n)]
	return uncapped if not failed else max(0.0, min(uncapped, cap))


	def normalise(results, graders, cap, faults):
	"""§5.3 literally: scored 0.0, and out of the denominator too."""
	faults = set(faults)
	measured = sum(w for n, w, _b in graders if n not in faults)
	if measured <= 0:
	return 0.0
	earned = sum(w for n, w, _b in graders if n not in faults and results.get(n))
	failed = [n for n, _w, b in graders if b and n not in faults and not results.get(n)]
	score = earned / measured
	return score if not failed else max(0.0, min(score, cap))


	def strike_no_ceiling(results, graders, cap, faults):
	"""Scored 0.0 and struck from the blocker set, without the unproven ceiling.

	The intermediate step, kept because it is the one that looks right and is
	not: striking a faulted BLOCKER also lifts the cap, and lifting the cap is
	worth the whole gap between it and 1.00 to a tree that would fail a gate.
	"""
	faults = set(faults)
	uncapped = sum(w for n, w, _b in graders if n not in faults and results.get(n))
	failed = [n for n, _w, b in graders if b and n not in faults and not results.get(n)]
	return uncapped if not failed else max(0.0, min(uncapped, cap))


	def strike(results, graders, cap, faults):
	"""Implemented: scored 0.0, not renormalised, unproven blockers keep the cap."""
	return M.reward(results, graders, cap, faults)[0]


	RULES = (("absolve", absolve), ("normalise", normalise),
	("no-ceiling", strike_no_ceiling), ("strike", strike))


	def main() -> None:
	graders, cap = M.load_table()
	names = [n for n, _w, _b in graders]
	weights = {n: w for n, w, _b in graders}
	rows = load_matrix()
	if not rows:
	raise SystemExit("no recorded rows use today's criterion names")

	print(f"{len(rows)} recorded trees, {len(names)} criteria, cap {cap:.2f}")
	print("gain = what the tree scores once one criterion it FAILS is turned "
	"into a fault, minus what it scores honestly\n")

	worst = {label: (-9.9, "", "") for label, _fn in RULES}
	print(f"{'tree':<28} {'criterion it breaks':<46} {'honest':>7} "
	+ " ".join(f"{label:>10}" for label, _fn in RULES))
	for tree in sorted(rows):
	results = rows[tree]
	honest = M.reward(results, graders, cap)[0]
	for c in names:
	if results.get(c):
	continue # it passes this one; breaking it can only cost
	line = f"{tree:<28} {c + f' (w={weights[c]:.2f})':<46} {honest:>7.3f}"
	for label, fn in RULES:
	got = fn(results, graders, cap, {c})
	gain = got - honest
	line += f" {got:>6.3f}{gain:+.3f}"
	if gain > worst[label][0]:
	worst[label] = (gain, tree, c)
	print(line)

	print("\n=== the most a tree can gain by breaking one fixture ===")
	for label, _fn in RULES:
	gain, tree, c = worst[label]
	verdict = "CHANNEL OPEN" if gain > 1e-9 else "closed"
	print(f" {label:<10} {gain:+.3f} ({tree}, {c}) -> {verdict}")

	# ─── the proof, as opposed to the illustration ─────────────────────────
	#
	# The rows above are the trees that happen to have been graded. The channel
	# is a property of the arithmetic, not of the sample, so: every one of the
	# 2^n outcome vectors a tree could possibly have, against every non-empty
	# subset of criteria it could turn into a fault. A rule is closed iff the
	# largest gain over the whole space is zero.
	print(f"\n=== every possible tree ({1 << len(names)} outcome vectors) x every "
	f"subset of faults ({(1 << len(names)) - 1}) ===")
	worst_all = {label: (-9.9, (), ()) for label, _fn in RULES}
	for outcome in range(1 << len(names)):
	results = {n: bool(outcome >> i & 1) for i, n in enumerate(names)}
	honest = M.reward(results, graders, cap)[0]
	for mask in range(1, 1 << len(names)):
	faults = {names[i] for i in range(len(names)) if mask >> i & 1}
	for label, fn in RULES:
	gain = fn(results, graders, cap, faults) - honest
	if gain > worst_all[label][0]:
	reds = tuple(n for n in names if not results[n])
	worst_all[label] = (gain, reds, tuple(sorted(faults)))
	for label, _fn in RULES:
	gain, reds, faults = worst_all[label]
	verdict = "CHANNEL OPEN" if gain > 1e-9 else "CLOSED"
	print(f" {label:<11} max gain {gain:+.3f} -> {verdict}")
	if gain > 1e-9:
	print(f" worst case: a tree failing {list(reds) or 'nothing'}")
	print(f" breaks {list(faults)}")

	strike_gain = worst_all["strike"][0]
	print("\n" + ("PASS: under the implemented rule, breaking any set of fixtures "
	"is never worth anything."
	if strike_gain <= 1e-9 else
	f"FAIL: the implemented rule still pays {strike_gain:+.3f}."))
	return 0 if strike_gain <= 1e-9 else 1


	if __name__ == "__main__":
	raise SystemExit(main())