| |
| """Offline release gate for the KLENT static audit candidate.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import hashlib |
| import json |
| import os |
| import re |
| import shutil |
| import stat |
| import subprocess |
| import sys |
| import tempfile |
| from pathlib import Path |
|
|
|
|
| ROOT = Path(__file__).resolve().parents[1] |
| PAPER_ID = "sSQdICPJv1" |
| EXPECTED_PATHS = { |
| "README.md", |
| "evidence/claims.json", |
| "evidence/claims_active.json", |
| "evidence/claims_anchored.json", |
| "evidence/provenance.json", |
| "index.html", |
| "manifest.sha256", |
| "pages/01-claim-matrix.md", |
| "pages/02-reproducibility-audit.md", |
| "pages/03-provenance-and-safety.md", |
| "release-allowlist.txt", |
| "scripts/verify_release.py", |
| } |
| REQUIRED_TAGS = ("icml2026-repro", "paper-sSQdICPJv1") |
| BOUNDARY = ( |
| "Evidence limit: this package is a released-paper source/proof audit and a static inspection of the author " |
| "repository. It is not an independent reproduction, it contains no author material, it ran no author code, " |
| "and it does not validate the reported numerical results." |
| ) |
| EXPECTED_DEFAULT = ( |
| "Regularized policy optimization with reverse KL and entropy divergence provides convergence guarantees on two-player zero-sum games", |
| "Algorithm demonstrates efficient learning on five board games: Animal Shogi, Gardner Chess, Go, Hex, and Othello", |
| ) |
| EXPECTED_ACTIVE = ( |
| "The regularized policy update combines reverse KL divergence and entropy regularization (weighted by parameters beta and alpha) with a closed-form analytical solution for the optimal policy pi'(a|s) (Section 4.1, Equations 2-3).", |
| "Theorem A.2 formally derives the closed-form regularized policy-update solution via Lagrange multipliers (Appendix A, Theorem A.2).", |
| "Using fixed hyperparameters alpha=0.03, beta=0.1, and lambda=e^(-1/8)≈0.88 across all five games, KLENT (the proposed algorithm) achieves roughly fourfold greater sample/compute efficiency than Gumbel AlphaZero on Animal Shogi, Gardner Chess, 9x9 Go, Hex, and Othello (Section 5.1, Figure 1, Figure 5, Table 1).", |
| "An ablation isolating KL-only, entropy-only, single-step, and Monte Carlo variants shows both KL regularization, entropy regularization, and lambda-returns each contribute to performance across all five games (Section 5.2, Figure 6, Table 2).", |
| "On 19x19 Go, KLENT achieves performance competitive with AlphaZero, demonstrating scalability beyond the smaller board-game benchmarks (Section 5.3, Figure 8).", |
| ) |
| EXPECTED_PROVENANCE = { |
| "challenge_revision": "7b5b56aebf3abe590eab9f2c241a796125cab928", |
| "claims_sha256": "af5ab2d62f786ae36861957cbd08b4188f6d4c86e67152becc661a9c5bbb9d57", |
| "claims_anchored_sha256": "eb3f2d878646ca5c40da121741a613c1f9e1e10c14845f373db107e74a4ef439", |
| "merge_code_sha256": "acdd7be31b6982ef1e6cb609e60e506abb57aa2199b0b55561a34ed9b25175c6", |
| } |
|
|
|
|
| def fail(message: str) -> None: |
| print(f"FAIL: {message}", file=sys.stderr) |
| raise SystemExit(1) |
|
|
|
|
| def sha256(path: Path) -> str: |
| return hashlib.sha256(path.read_bytes()).hexdigest() |
|
|
|
|
| def public_files(root: Path) -> set[str]: |
| files: set[str] = set() |
| for directory, dirnames, filenames in os.walk(root, followlinks=False): |
| relative_dir = Path(directory).relative_to(root) |
| if ".git" in dirnames: |
| dirnames.remove(".git") |
| for name in filenames: |
| path = Path(directory, name) |
| if path.is_symlink(): |
| fail(f"symlink is forbidden: {path.relative_to(root)}") |
| files.add(str(relative_dir / name)) |
| return files |
|
|
|
|
| def load_manifest(root: Path) -> dict[str, str]: |
| entries: dict[str, str] = {} |
| for line in (root / "manifest.sha256").read_text(encoding="utf-8").splitlines(): |
| digest, separator, path = line.partition(" ") |
| if not separator or len(digest) != 64 or path in entries: |
| fail("malformed manifest") |
| entries[path] = digest |
| return entries |
|
|
|
|
| def claim_texts(entries: list[dict[str, str]]) -> tuple[str, ...]: |
| if any(set(entry) != {"text", "status"} or entry["status"] != "unverified" for entry in entries): |
| fail("claim structure or status differs from the pinned target") |
| return tuple(entry["text"] for entry in entries) |
|
|
|
|
| def check(root: Path) -> None: |
| actual_paths = public_files(root) |
| if actual_paths != EXPECTED_PATHS: |
| fail(f"release inventory mismatch: {sorted(actual_paths ^ EXPECTED_PATHS)}") |
|
|
| allowlist = set((root / "release-allowlist.txt").read_text(encoding="utf-8").splitlines()) |
| if allowlist != EXPECTED_PATHS: |
| fail("release allowlist is not the exact expected inventory") |
|
|
| for relative in EXPECTED_PATHS: |
| if stat.S_IMODE((root / relative).stat().st_mode) != 0o644: |
| fail(f"unexpected file mode: {relative}") |
|
|
| manifest = load_manifest(root) |
| expected_manifest_paths = EXPECTED_PATHS - {"manifest.sha256"} |
| if set(manifest) != expected_manifest_paths: |
| fail("manifest inventory is incomplete or has undeclared paths") |
| for relative, digest in manifest.items(): |
| if sha256(root / relative) != digest: |
| fail(f"hash mismatch: {relative}") |
|
|
| readme = (root / "README.md").read_text(encoding="utf-8") |
| if not all(tag in readme for tag in REQUIRED_TAGS): |
| fail("required discovery tags are missing") |
| if "sdk: static" not in readme or "app_file: index.html" not in readme: |
| fail("static Space metadata is missing") |
| if BOUNDARY not in readme: |
| fail("immutable evidence boundary is missing from README") |
|
|
| defaults = json.loads((root / "evidence/claims.json").read_text(encoding="utf-8")) |
| anchored = json.loads((root / "evidence/claims_anchored.json").read_text(encoding="utf-8")) |
| active = json.loads((root / "evidence/claims_active.json").read_text(encoding="utf-8")) |
| if set(defaults) != {PAPER_ID} or set(anchored) != {PAPER_ID}: |
| fail("claim extracts must contain only the target OpenReview ID") |
| if claim_texts(defaults[PAPER_ID]) != EXPECTED_DEFAULT: |
| fail("default claims differ from the pinned target extract") |
| if claim_texts(anchored[PAPER_ID]) != EXPECTED_ACTIVE: |
| fail("anchored claims differ from the pinned target extract") |
| if active.get("openreview_id") != PAPER_ID or active.get("active_source") != "claims_anchored.json": |
| fail("active claim provenance is incorrect") |
| if claim_texts(active.get("claims", [])) != EXPECTED_ACTIVE: |
| fail("active claims do not exactly equal the anchored override") |
|
|
| provenance = json.loads((root / "evidence/provenance.json").read_text(encoding="utf-8")) |
| official = provenance.get("official_claim_feeds", {}) |
| if provenance.get("openreview_id") != PAPER_ID or any(official.get(key) != value for key, value in EXPECTED_PROVENANCE.items()): |
| fail("immutable official-feed provenance differs from the pinned values") |
| if provenance.get("released_repository", {}).get("licence_status", "").startswith("No licence") is False: |
| fail("no-redistribution licence decision is missing") |
|
|
| page_text = "\n".join(path.read_text(encoding="utf-8") for path in sorted((root / "pages").glob("*.md"))) |
| if len("".join(page_text.split())) < 200: |
| fail("combined stripped page text is under 200 characters") |
| if "Not reproducible for the central numerical claims" not in page_text: |
| fail("reproducibility status is missing") |
|
|
| html = (root / "index.html").read_text(encoding="utf-8") |
| lowered = html.lower() |
| if BOUNDARY not in html: |
| fail("immutable evidence boundary is missing from static HTML") |
| if any(token in lowered for token in ("<script", "<iframe", "<object", "<embed", "http://", "https://")): |
| fail("active or externally fetched HTML payload is forbidden") |
| if re.search(r"\son[a-z]+\s*=", lowered): |
| fail("inline HTML event handler is forbidden") |
|
|
|
|
| def negative_tamper_tests() -> None: |
| with tempfile.TemporaryDirectory(prefix="klent-static-audit-") as temporary: |
| copy_root = Path(temporary) / "candidate" |
| shutil.copytree(ROOT, copy_root, ignore=shutil.ignore_patterns(".git")) |
| script = copy_root / "scripts/verify_release.py" |
|
|
| (copy_root / "tamper.txt").write_text("unexpected", encoding="utf-8") |
| extra = subprocess.run([sys.executable, str(script), "--check"], capture_output=True, text=True) |
| if extra.returncode == 0 or "release inventory mismatch" not in extra.stderr: |
| fail("negative inventory tamper test did not fail as expected") |
| (copy_root / "tamper.txt").unlink() |
|
|
| readme = copy_root / "README.md" |
| readme.write_text(readme.read_text(encoding="utf-8") + "\ntampered\n", encoding="utf-8") |
| modified = subprocess.run([sys.executable, str(script), "--check"], capture_output=True, text=True) |
| if modified.returncode == 0 or "hash mismatch" not in modified.stderr: |
| fail("negative content tamper test did not fail as expected") |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--check", action="store_true", help="run the offline release checks only") |
| parser.add_argument("--self-test", action="store_true", help="also run negative tamper tests in a temporary copy") |
| arguments = parser.parse_args() |
| if arguments.check and arguments.self_test: |
| fail("choose at most one mode") |
| check(ROOT) |
| if arguments.self_test: |
| negative_tamper_tests() |
| print("PASS: release checks and negative tamper tests") |
| else: |
| print("PASS: exact inventory, hashes, tags, claims, provenance, boundary, page length, and inert HTML checks") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
