File size: 18,912 Bytes
0b28a2c 2ec3b18 0b28a2c | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 | #!/usr/bin/env python3
"""Dependency-free structural, integrity, and leakage checks for the release."""
from __future__ import annotations
import hashlib
import json
import re
import sys
import urllib.parse
from collections import Counter
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
EXPECTED_IDS = [
"erdos_001",
"erdos_003",
"erdos_025",
"erdos_075",
"erdos_149",
*[f"aim_ag_{index:03d}" for index in range(1, 11)],
"counterexample_114",
"counterexample_128",
"counterexample_131",
"counterexample_134",
"counterexample_135",
]
EXPECTED_STREAMS = {
"erdos_variant": 5,
"aim_ag_rl": 10,
"counterexample_variant": 5,
}
EXPECTED_AIM_MILESTONE_COUNTS = [5, 4, 4, 4, 5, 4, 4, 4, 4, 4]
EXPECTED_AIM_REFERENCE_COUNTS = [5, 7, 5, 5, 6, 6, 5, 6, 4, 5]
EXPECTED_JSONL_COUNTS = {
"data/showcase.jsonl": 20,
"data/erdos_variants.jsonl": 5,
"data/aim_ag_tasks.jsonl": 10,
"data/counterexample_variants.jsonl": 5,
"rl/data/public_tasks.jsonl": 10,
"rl/data/curriculum_episodes.jsonl": 53,
"rl/data/curriculum_episodes_hf.jsonl": 53,
"rl/data/curriculum_train_hf.jsonl": 18,
"rl/data/curriculum_validation_hf.jsonl": 14,
"rl/data/curriculum_test_hf.jsonl": 21,
"rl/data/exact_benchmark_public.jsonl": 33,
"rl/data/exact_benchmark_train.jsonl": 11,
"rl/data/exact_benchmark_validation.jsonl": 11,
"rl/data/exact_benchmark_test.jsonl": 11,
"rl/data/frontier_eval_public.jsonl": 10,
}
EXPECTED_CONFIG_PATHS = set(EXPECTED_JSONL_COUNTS) - {
"rl/data/curriculum_episodes.jsonl",
"rl/data/curriculum_episodes_hf.jsonl",
"rl/data/exact_benchmark_public.jsonl",
}
def fail(message: str) -> None:
raise AssertionError(message)
def sha256(path: Path) -> str:
digest = hashlib.sha256()
with path.open("rb") as handle:
for block in iter(lambda: handle.read(1024 * 1024), b""):
digest.update(block)
return digest.hexdigest()
def read_json(path: Path):
with path.open("r", encoding="utf-8") as handle:
return json.load(handle)
def read_jsonl(path: Path) -> list[dict]:
rows = []
with path.open("r", encoding="utf-8") as handle:
for line_number, line in enumerate(handle, start=1):
if not line.strip():
fail(f"Blank JSONL line: {path}:{line_number}")
try:
value = json.loads(line)
except json.JSONDecodeError as exc:
fail(f"Invalid JSONL: {path}:{line_number}: {exc}")
if not isinstance(value, dict):
fail(f"JSONL row is not an object: {path}:{line_number}")
rows.append(value)
return rows
def check_showcase(rows: list[dict]) -> None:
schema = read_json(ROOT / "schema/showcase.schema.json")
required = set(schema["required"])
expected_properties = set(schema["properties"])
ids = []
for row_number, row in enumerate(rows, start=1):
missing = required - set(row)
extra = set(row) - expected_properties
if missing or extra:
fail(f"Showcase row {row_number}: missing={sorted(missing)}, extra={sorted(extra)}")
if row["schema_version"] != "1.0.0" or row["license"] != "MIT":
fail(f"Showcase row {row_number}: schema/license mismatch")
if row["stream"] not in EXPECTED_STREAMS:
fail(f"Showcase row {row_number}: unknown stream")
for field in [
"problem_id",
"title",
"domain",
"task_type",
"difficulty",
"prompt",
"inspiration",
"rationale",
"expected_output",
"research_status",
"verification",
]:
if not isinstance(row[field], str) or not row[field].strip():
fail(f"Showcase row {row_number}: invalid {field}")
if not isinstance(row["source_record_index"], int) or row["source_record_index"] < 1:
fail(f"Showcase row {row_number}: invalid source_record_index")
if not isinstance(row["rl_ready"], bool):
fail(f"Showcase row {row_number}: rl_ready must be boolean")
if not isinstance(row["milestones"], list):
fail(f"Showcase row {row_number}: milestones must be a list")
if not isinstance(row["quality_signals"], list) or not row["quality_signals"]:
fail(f"Showcase row {row_number}: quality_signals must be nonempty")
if row["rl_ready"] != (row["stream"] == "aim_ag_rl"):
fail(f"Showcase row {row_number}: rl_ready conflicts with stream")
ids.append(row["problem_id"])
if ids != EXPECTED_IDS:
fail(f"Unexpected showcase IDs/order: {ids}")
if len(ids) != len(set(ids)):
fail("Duplicate showcase problem IDs")
if Counter(row["stream"] for row in rows) != Counter(EXPECTED_STREAMS):
fail("Unexpected stream counts")
def check_aim_tasks(rows: list[dict]) -> None:
expected_ids = [f"aim_ag_{index:03d}" for index in range(1, 11)]
actual_ids = [row.get("release_problem_id") for row in rows]
if actual_ids != expected_ids:
fail(f"Unexpected AIM-AG IDs: {actual_ids}")
for source_index, row in enumerate(rows, start=1):
source_id = f"sample_{source_index}"
if row.get("problem_id") != source_id:
fail(f"Unexpected AIM-AG source ID: {row.get('problem_id')}")
research_status = row.get("research_status", {})
if research_status.get("classification") != "candidate_open_problem":
fail(f"Unexpected AIM-AG research status: {source_id}")
if research_status.get("expert_signoff_required") is not True:
fail(f"AIM-AG expert-signoff flag is missing: {source_id}")
milestones = row.get("evaluation", {}).get("milestones", [])
if len(milestones) != EXPECTED_AIM_MILESTONE_COUNTS[source_index - 1]:
fail(f"Unexpected AIM-AG milestone count: {source_id}")
expected_milestones = [f"m{index}" for index in range(1, len(milestones) + 1)]
if [item.get("milestone_id") for item in milestones] != expected_milestones:
fail(f"AIM-AG milestones are not sequential: {source_id}")
if sum(item.get("weight_percent", 0) for item in milestones) != 100:
fail(f"AIM-AG milestone weights do not sum to 100: {row['release_problem_id']}")
references = row.get("research_context", {}).get("references", [])
if len(references) != EXPECTED_AIM_REFERENCE_COUNTS[source_index - 1]:
fail(f"Unexpected AIM-AG reference count: {source_id}")
for reference in references:
parsed = urllib.parse.urlparse(reference.get("url", ""))
if parsed.scheme != "https" or not parsed.netloc:
fail(f"Invalid AIM-AG reference URL: {source_id}")
if row.get("license") != "MIT":
fail(f"AIM-AG license missing: {row['release_problem_id']}")
def check_lossless_episode_view(source_rows: list[dict], normalized_rows: list[dict]) -> None:
if [row.get("episode_id") for row in normalized_rows] != [
row.get("episode_id") for row in source_rows
]:
fail("Type-stable curriculum IDs/order do not match production-format public rows")
direct_fields = [
"schema_version",
"episode_id",
"episode_type",
"problem_id",
"split",
"reward_mode",
"policy_visibility",
"submission_schema_ref",
]
optional_defaults = {
"milestone_id": "",
"target_milestone_ids": [],
"milestone_target": "",
"required_artifact_policy": "",
"verifier_id": "",
"candidate_required_fields": [],
}
for source, normalized in zip(source_rows, normalized_rows):
episode_id = source["episode_id"]
if normalized.get("source_fields") != sorted(source):
fail(f"Lossless-view source field inventory mismatch: {episode_id}")
prompt = source["prompt"]
expected_kind = "object" if isinstance(prompt, dict) else "string"
if normalized.get("prompt_kind") != expected_kind:
fail(f"Lossless-view prompt kind mismatch: {episode_id}")
if json.loads(normalized.get("prompt_json", "null")) != prompt:
fail(f"Lossless-view prompt JSON mismatch: {episode_id}")
expected_prompt_text = (
json.dumps(prompt, ensure_ascii=False, sort_keys=True)
if isinstance(prompt, dict)
else str(prompt)
)
if normalized.get("prompt_text") != expected_prompt_text:
fail(f"Lossless-view prompt text mismatch: {episode_id}")
expected_input = (
json.dumps(source["input"], ensure_ascii=False, sort_keys=True)
if "input" in source
else ""
)
if normalized.get("input_json") != expected_input:
fail(f"Lossless-view input mismatch: {episode_id}")
for field in direct_fields:
if normalized.get(field) != source.get(field):
fail(f"Lossless-view {field} mismatch: {episode_id}")
for field, default in optional_defaults.items():
if normalized.get(field) != source.get(field, default):
fail(f"Lossless-view {field} mismatch: {episode_id}")
def check_rl_public(aim_rows: list[dict]) -> None:
public_paths = [
"rl/data/public_tasks.jsonl",
"rl/data/curriculum_episodes.jsonl",
"rl/data/curriculum_episodes_hf.jsonl",
"rl/data/curriculum_train_hf.jsonl",
"rl/data/curriculum_validation_hf.jsonl",
"rl/data/curriculum_test_hf.jsonl",
"rl/data/exact_benchmark_public.jsonl",
"rl/data/exact_benchmark_train.jsonl",
"rl/data/exact_benchmark_validation.jsonl",
"rl/data/exact_benchmark_test.jsonl",
"rl/data/frontier_eval_public.jsonl",
]
valid_problem_ids = {f"sample_{index}" for index in range(1, 11)}
for relative in public_paths:
for row in read_jsonl(ROOT / relative):
if row.get("policy_visibility") != "public":
fail(f"Non-public RL row found in {relative}")
if row.get("problem_id") not in valid_problem_ids:
fail(f"Unknown RL problem ID in {relative}: {row.get('problem_id')}")
schema_ref = row.get("submission_schema_ref")
if schema_ref and not (ROOT / "rl" / schema_ref).is_file():
fail(f"Broken RL schema reference in {relative}: {schema_ref}")
tasks = read_jsonl(ROOT / "rl/data/public_tasks.jsonl")
if [row["problem_id"] for row in tasks] != [f"sample_{index}" for index in range(1, 11)]:
fail("Public RL tasks are not ordered sample_1 through sample_10")
aim_by_source_id = {row["problem_id"]: row for row in aim_rows}
task_by_id = {row["problem_id"]: row for row in tasks}
for problem_id, task in task_by_id.items():
aim = aim_by_source_id[problem_id]
if task.get("title") != aim.get("title"):
fail(f"AIM-AG/RL title mismatch: {problem_id}")
for field in ["conjecture", "definitions"]:
if task.get("prompt", {}).get(field) != aim.get("prompt", {}).get(field):
fail(f"AIM-AG/RL core prompt mismatch ({field}): {problem_id}")
episodes = read_jsonl(ROOT / "rl/data/curriculum_episodes.jsonl")
episode_ids = [row["episode_id"] for row in episodes]
if len(episode_ids) != len(set(episode_ids)):
fail("Duplicate public curriculum episode IDs")
for row in episodes:
if isinstance(row.get("prompt"), dict):
task_prompt = task_by_id[row["problem_id"]]["prompt"]
for field in ["conjecture", "definitions"]:
if row["prompt"].get(field) != task_prompt.get(field):
fail(f"Structured episode/RL task mismatch ({field}): {row['episode_id']}")
exact = read_jsonl(ROOT / "rl/data/exact_benchmark_public.jsonl")
frontier = read_jsonl(ROOT / "rl/data/frontier_eval_public.jsonl")
if exact != [row for row in episodes if row["episode_type"] == "exact_benchmark"]:
fail("Exact benchmark file is not the exact-episode subset of the curriculum")
if frontier != [row for row in episodes if row["episode_type"] == "full_frontier_task"]:
fail("Frontier eval file is not the full-frontier subset of the curriculum")
normalized = read_jsonl(ROOT / "rl/data/curriculum_episodes_hf.jsonl")
check_lossless_episode_view(episodes, normalized)
split_names = {"train": "train", "dev": "validation", "eval": "test"}
for source_split, hf_split in split_names.items():
if read_jsonl(ROOT / f"rl/data/curriculum_{hf_split}_hf.jsonl") != [
row for row in normalized if row["split"] == source_split
]:
fail(f"Curriculum {hf_split} split is inconsistent")
if read_jsonl(ROOT / f"rl/data/exact_benchmark_{hf_split}.jsonl") != [
row for row in exact if row["split"] == source_split
]:
fail(f"Exact benchmark {hf_split} split is inconsistent")
fixtures = {
path.stem: read_json(path) for path in (ROOT / "rl/fixtures/public").glob("*.json")
}
exact_by_id = {row["episode_id"]: row for row in exact}
if fixtures != exact_by_id:
fail("Public fixture files do not match public exact episodes one-to-one")
curriculum_config = read_json(ROOT / "rl/configs/training_curriculum.json")
public_scope = curriculum_config.get("public_release_scope", {})
if public_scope.get("all_included_prompts_and_fixtures_are_public") is not True:
fail("Training curriculum lacks the public-release fixture override")
if any("held-out" in stage.get("name", "").lower() for stage in curriculum_config["stages"]):
fail("Training curriculum still labels a public stage as held out")
leaked_paths = [
path.relative_to(ROOT).as_posix()
for path in (ROOT / "rl").rglob("*")
if path.is_file() and "hidden" in path.relative_to(ROOT).as_posix().lower()
]
if leaked_paths:
fail(f"Hidden-path assets included: {leaked_paths}")
def check_version_consistency() -> None:
version = (ROOT / "VERSION").read_text(encoding="utf-8").strip()
manifest = read_json(ROOT / "MANIFEST.json")
citation = (ROOT / "CITATION.cff").read_text(encoding="utf-8")
readme = (ROOT / "README.md").read_text(encoding="utf-8")
if version != "0.1.0":
fail(f"Unexpected release version: {version}")
if manifest.get("release_version") != version:
fail("VERSION and manifest release_version differ")
if not re.search(rf"^version:\s*{re.escape(version)}\s*$", citation, re.MULTILINE):
fail("VERSION and CITATION.cff version differ")
if f"version = {{{version}}}" not in readme:
fail("VERSION and README BibTeX version differ")
def check_readme_configs() -> None:
readme = (ROOT / "README.md").read_text(encoding="utf-8")
if not readme.startswith("---\n") or "\nlicense: mit\n" not in readme:
fail("README metadata is missing YAML front matter or MIT license")
front_matter = readme.split("---", 2)[1]
config_paths = re.findall(r"^\s+path:\s+([^\s]+)\s*$", front_matter, flags=re.MULTILINE)
if set(config_paths) != EXPECTED_CONFIG_PATHS:
fail(
f"README config paths mismatch: missing={sorted(EXPECTED_CONFIG_PATHS-set(config_paths))}, "
f"extra={sorted(set(config_paths)-EXPECTED_CONFIG_PATHS)}"
)
for relative in config_paths:
if not (ROOT / relative).is_file():
fail(f"README config points to missing file: {relative}")
def check_sensitive_strings() -> None:
patterns = {
"absolute local path": re.compile("/" + "Users/" + "black" + "frog/"),
"Hugging Face token": re.compile(r"hf_[A-Za-z0-9]{20,}"),
"generic API secret": re.compile(r"sk-[A-Za-z0-9_-]{20,}"),
}
for path in ROOT.rglob("*"):
if not path.is_file() or path.name == ".DS_Store":
continue
try:
text = path.read_text(encoding="utf-8")
except UnicodeDecodeError:
continue
for label, pattern in patterns.items():
if pattern.search(text):
fail(f"Possible {label} in {path.relative_to(ROOT)}")
def check_manifest() -> None:
manifest = read_json(ROOT / "MANIFEST.json")
if manifest.get("publication_status") != "published_public":
fail("Manifest publication status is not published_public")
listed = manifest.get("files", [])
for item in listed:
path = ROOT / item["path"]
if not path.is_file():
fail(f"Manifest file is missing: {item['path']}")
if path.stat().st_size != item["bytes"] or sha256(path) != item["sha256"]:
fail(f"Manifest integrity mismatch: {item['path']}")
actual_paths = {
path.relative_to(ROOT).as_posix()
for path in ROOT.rglob("*")
if path.is_file() and path.name not in {".DS_Store", "MANIFEST.json"}
}
listed_paths = {item["path"] for item in listed}
if actual_paths != listed_paths:
fail(
f"Manifest file set mismatch: missing={sorted(actual_paths-listed_paths)}, "
f"stale={sorted(listed_paths-actual_paths)}"
)
content_digest = hashlib.sha256()
for item in listed:
content_digest.update(f"{item['path']}\0{item['sha256']}\n".encode("utf-8"))
if content_digest.hexdigest() != manifest.get("content_set_sha256"):
fail("Manifest content-set hash mismatch")
def main() -> int:
for relative, expected_count in EXPECTED_JSONL_COUNTS.items():
rows = read_jsonl(ROOT / relative)
if len(rows) != expected_count:
fail(f"{relative}: expected {expected_count} rows, found {len(rows)}")
showcase = read_jsonl(ROOT / "data/showcase.jsonl")
check_showcase(showcase)
aim_rows = read_jsonl(ROOT / "data/aim_ag_tasks.jsonl")
check_aim_tasks(aim_rows)
check_rl_public(aim_rows)
check_readme_configs()
check_sensitive_strings()
check_version_consistency()
check_manifest()
print("PASS: release structure, counts, IDs, public visibility, metadata, versions, and hashes")
print("PASS: 20 showcase problems = 5 Erdős + 10 AIM-AG + 5 counterexample variants")
print("PASS: AIM-AG/RL mathematical cores align; type-stable episodes round-trip losslessly")
print("PASS: curriculum/exact/frontier subsets, native splits, and 33 fixtures align")
print("PASS: no hidden-path files or obvious local paths/API tokens")
return 0
if __name__ == "__main__":
try:
sys.exit(main())
except (AssertionError, FileNotFoundError, json.JSONDecodeError) as exc:
print(f"FAIL: {exc}", file=sys.stderr)
sys.exit(1)
|