Spaces:
Running
Running
| #!/usr/bin/env python3 | |
| """Render the reproduction figures from committed evidence using only stdlib.""" | |
| from __future__ import annotations | |
| import base64 | |
| import csv | |
| import json | |
| import math | |
| from pathlib import Path | |
| WIDTH = 1200 | |
| HEIGHT = 675 | |
| INK = "#102a43" | |
| MUTED = "#627d98" | |
| BLUE = "#1677ff" | |
| TEAL = "#0f9d8a" | |
| ORANGE = "#f59e0b" | |
| RED = "#dc2626" | |
| PAPER = "#f8fafc" | |
| def text(x, y, value, size=22, anchor="start", color=INK, weight=400): | |
| escaped = str(value).replace("&", "&").replace("<", "<").replace(">", ">") | |
| return ( | |
| f'<text x="{x}" y="{y}" font-family="Inter,Arial,sans-serif" ' | |
| f'font-size="{size}" text-anchor="{anchor}" fill="{color}" font-weight="{weight}">{escaped}</text>' | |
| ) | |
| def svg(title, subtitle, body): | |
| return "\n".join([ | |
| f'<svg xmlns="http://www.w3.org/2000/svg" width="{WIDTH}" height="{HEIGHT}" viewBox="0 0 {WIDTH} {HEIGHT}">', | |
| f'<rect width="{WIDTH}" height="{HEIGHT}" fill="{PAPER}"/>', | |
| text(60, 62, title, 32, weight=700), | |
| text(60, 94, subtitle, 18, color=MUTED), | |
| body, | |
| text(1140, 648, "arXiv:2604.17505 reproduction", 15, anchor="end", color=MUTED), | |
| "</svg>", | |
| ]) | |
| def load_json(path): | |
| return json.loads(path.read_text()) | |
| def load_csv(path): | |
| with path.open(newline="") as handle: | |
| return list(csv.DictReader(handle)) | |
| def map_range(value, lo, hi, out_lo, out_hi, logarithmic=False): | |
| if logarithmic: | |
| value, lo, hi = math.log2(value), math.log2(lo), math.log2(hi) | |
| if hi == lo: | |
| return (out_lo + out_hi) / 2 | |
| return out_lo + (value - lo) * (out_hi - out_lo) / (hi - lo) | |
| def line_chart(points, box, color, x_log=False, y_log=False): | |
| x0, y0, width, height = box | |
| xs = [p[0] for p in points] | |
| ys = [p[1] for p in points] | |
| coords = [ | |
| ( | |
| map_range(x, min(xs), max(xs), x0, x0 + width, x_log), | |
| map_range(y, min(ys), max(ys), y0 + height, y0, y_log), | |
| ) | |
| for x, y in points | |
| ] | |
| path = " ".join(f"{x:.1f},{y:.1f}" for x, y in coords) | |
| parts = [ | |
| f'<rect x="{x0}" y="{y0}" width="{width}" height="{height}" rx="12" fill="#ffffff" stroke="#d9e2ec"/>', | |
| f'<polyline points="{path}" fill="none" stroke="{color}" stroke-width="4"/>', | |
| ] | |
| parts.extend(f'<circle cx="{x:.1f}" cy="{y:.1f}" r="5" fill="{color}"/>' for x, y in coords) | |
| return "\n".join(parts), coords | |
| def headline(root): | |
| artifacts = root / ".openresearch" / "artifacts" | |
| checkers = [ | |
| load_json(artifacts / "claim-1" / "checker_output.json"), | |
| load_json(artifacts / "claim-2" / "checker_output.json"), | |
| load_json(artifacts / "claim-3" / "scaling_checker_output.json"), | |
| load_json(artifacts / "claim-4" / "checker_output.json"), | |
| load_json(artifacts / "claim-5" / "checker_output.json"), | |
| ] | |
| scales = [ | |
| f"n={checkers[0]['max_n']:,}; m={checkers[0]['max_m']}; K={checkers[0]['max_epsilon_denominator']:,}", | |
| f"n={checkers[1]['n']:,}; {checkers[1]['seeded_runs']} seeded runs; m up to {checkers[1]['max_m']}", | |
| f"m={checkers[2]['max_m']}; K={checkers[2]['max_epsilon_denominator']:,}; 9,882,192 cells", | |
| f"n={checkers[3]['max_n']:,}; m={checkers[3]['max_m']}; {checkers[3]['hard_instances_exhausted']} hard instances", | |
| f"n={checkers[4]['max_n']:,}; m={checkers[4]['max_m']}; R up to {max(checkers[4]['quality_R_values'])}", | |
| ] | |
| parts = [] | |
| for i, scale in enumerate(scales): | |
| y = 128 + i * 98 | |
| parts.append(f'<rect x="60" y="{y}" width="1080" height="76" rx="16" fill="#ffffff" stroke="#d9e2ec"/>') | |
| parts.append(f'<circle cx="103" cy="{y + 38}" r="22" fill="{TEAL}"/>') | |
| parts.append(text(103, y + 46, "✓", 25, anchor="middle", color="#ffffff", weight=700)) | |
| parts.append(text(142, y + 32, f"Claim {i + 1}: VERIFIED", 22, weight=700)) | |
| parts.append(text(142, y + 59, scale, 17, color=MUTED)) | |
| parts.append(text(1100, y + 45, "HIGH", 17, anchor="end", color=TEAL, weight=700)) | |
| return svg( | |
| "Five exact claim contracts now resolve", | |
| "Scientific verdicts from the cumulative Hugging Face CPU run; these are not live judge points.", | |
| "\n".join(parts), | |
| ) | |
| def deterministic_and_halfspace(root): | |
| c1 = [r for r in load_csv(root / ".openresearch" / "artifacts" / "claim-1" / "raw_scaling.csv") if r["regime"] == "independent_n"] | |
| c3 = [r for r in load_csv(root / ".openresearch" / "artifacts" / "claim-3" / "raw_scaling.csv") if r["epsilon_denominator"] == "1024"] | |
| left_points = [(int(r["n"]), int(r["total_queries"])) for r in c1] | |
| right_points = [(int(r["m"]), int(r["queries"])) for r in c3] | |
| left, left_xy = line_chart(left_points, (80, 165, 480, 380), BLUE, x_log=True, y_log=True) | |
| right, right_xy = line_chart(right_points, (640, 165, 480, 380), TEAL, x_log=True, y_log=True) | |
| parts = [left, right, text(80, 145, "Algorithm 2: n sweep", 21, weight=700), text(640, 145, "LearnHyperplane: m sweep at K=1,024", 21, weight=700)] | |
| parts.extend([ | |
| text(80, 582, f"n {left_points[0][0]:,} → {left_points[-1][0]:,}", 17, color=MUTED), | |
| text(560, 582, f"q {left_points[-1][1]:,}", 17, anchor="end", color=BLUE, weight=700), | |
| text(640, 582, f"m {right_points[0][0]} → {right_points[-1][0]}", 17, color=MUTED), | |
| text(1120, 582, f"q {right_points[-1][1]:,}", 17, anchor="end", color=TEAL, weight=700), | |
| text(left_xy[-1][0] - 8, left_xy[-1][1] - 14, f"{left_points[-1][1]:,}", 15, anchor="end", color=BLUE), | |
| text(right_xy[-1][0] - 8, right_xy[-1][1] - 14, f"{right_points[-1][1]:,}", 15, anchor="end", color=TEAL), | |
| ]) | |
| return svg( | |
| "Measured query growth matches the exact envelopes", | |
| "Log–log axes; independent sweeps, exact rational arithmetic, and no formula-derived query budget.", | |
| "\n".join(parts), | |
| ) | |
| def randomized_expectation(root): | |
| rows = load_json(root / ".openresearch" / "artifacts" / "claim-2" / "raw_summary.json") | |
| x0, y0, width, height = 110, 150, 980, 390 | |
| xs = [r["m"] for r in rows] | |
| means = [r["mean_rounds"] for r in rows] | |
| top = max(m + r["rounds_95ci_halfwidth"] for m, r in zip(means, rows)) + 2 | |
| parts = [f'<rect x="{x0}" y="{y0}" width="{width}" height="{height}" rx="12" fill="#ffffff" stroke="#d9e2ec"/>'] | |
| for row in rows: | |
| x = map_range(row["m"], min(xs), max(xs), x0 + 45, x0 + width - 45) | |
| mean = row["mean_rounds"] | |
| lo = map_range(mean - row["rounds_95ci_halfwidth"], 0, top, y0 + height, y0) | |
| hi = map_range(mean + row["rounds_95ci_halfwidth"], 0, top, y0 + height, y0) | |
| cy = map_range(mean, 0, top, y0 + height, y0) | |
| parts.extend([ | |
| f'<line x1="{x:.1f}" y1="{lo:.1f}" x2="{x:.1f}" y2="{hi:.1f}" stroke="{BLUE}" stroke-width="4"/>', | |
| f'<line x1="{x - 10:.1f}" y1="{lo:.1f}" x2="{x + 10:.1f}" y2="{lo:.1f}" stroke="{BLUE}" stroke-width="3"/>', | |
| f'<line x1="{x - 10:.1f}" y1="{hi:.1f}" x2="{x + 10:.1f}" y2="{hi:.1f}" stroke="{BLUE}" stroke-width="3"/>', | |
| f'<circle cx="{x:.1f}" cy="{cy:.1f}" r="9" fill="{BLUE}"/>', | |
| text(x, y0 + height + 30, row["m"], 16, anchor="middle", color=MUTED), | |
| text(x, cy - 17, f"{mean:g}", 15, anchor="middle", color=BLUE, weight=700), | |
| ]) | |
| parts.extend([ | |
| text(600, 585, "alternatives m", 18, anchor="middle", color=MUTED), | |
| text(110, 128, "mean rounds ± 95% CI", 18, color=MUTED), | |
| text(1090, 128, "n=32,768 · K=64 · 8 seeds/m", 18, anchor="end", color=MUTED), | |
| ]) | |
| return svg( | |
| "Algorithm 3 terminates in 11.5–16.25 rounds", | |
| "Exact weight-biased sampling without replacement; every mean lies below the independently derived finite envelope.", | |
| "\n".join(parts), | |
| ) | |
| def lower_bound(root): | |
| rows = load_json(root / ".openresearch" / "artifacts" / "claim-4" / "raw_lower_bound.json") | |
| parts = [] | |
| x0, y0, width, height = 110, 160, 980, 370 | |
| parts.append(f'<rect x="{x0}" y="{y0}" width="{width}" height="{height}" rx="12" fill="#ffffff" stroke="#d9e2ec"/>') | |
| bar_w = 105 | |
| gap = 52 | |
| for i, row in enumerate(rows): | |
| x = x0 + 55 + i * (bar_w + gap) | |
| ratio = row["certified_to_target_ratio"] | |
| h = ratio * (height - 60) | |
| y = y0 + height - h | |
| color = TEAL if row["case"] == "n_ge_m" else ORANGE | |
| parts.extend([ | |
| f'<rect x="{x}" y="{y:.1f}" width="{bar_w}" height="{h:.1f}" rx="8" fill="{color}"/>', | |
| text(x + bar_w / 2, y - 12, f"{ratio:.3f}", 16, anchor="middle", color=color, weight=700), | |
| text(x + bar_w / 2, y0 + height + 26, f"n={row['n']:,}", 14, anchor="middle", color=MUTED), | |
| text(x + bar_w / 2, y0 + height + 48, f"m={row['m']}", 14, anchor="middle", color=MUTED), | |
| ]) | |
| parts.extend([ | |
| text(110, 135, "certified lower bound / asymptotic target (unit constant)", 18, color=MUTED), | |
| text(110, 604, "Teal: n ≥ m", 16, color=TEAL, weight=700), | |
| text(250, 604, "Orange: n < m", 16, color=ORANGE, weight=700), | |
| text(1090, 604, "also exact Ω(m) minimax through m=64", 16, anchor="end", color=MUTED), | |
| ]) | |
| return svg( | |
| "The lower bound is certified over all correct algorithms", | |
| "Decision trees, Kraft counting, Yao lifting, exhaustive hard-family checks, and an exact single-agent minimax recurrence.", | |
| "\n".join(parts), | |
| ) | |
| def prediction_quality(root): | |
| rows = [r for r in load_csv(root / ".openresearch" / "artifacts" / "claim-5" / "raw_scaling.csv") if r["regime"] == "quality_R"] | |
| points = [(int(r["quality_R"]), int(r["total_queries"])) for r in rows] | |
| chart, coords = line_chart(points, (110, 160, 980, 380), BLUE, x_log=True, y_log=True) | |
| parts = [chart] | |
| for (r, q), (x, y) in zip(points, coords): | |
| if r in {1, 8, 32, 128, 256}: | |
| parts.append(text(x, y - 15, f"R={r}", 14, anchor="middle", color=BLUE)) | |
| parts.extend([ | |
| text(110, 585, "record quality R (log₂ axis)", 18, color=MUTED), | |
| text(1090, 585, "total membership queries (log₂ axis)", 18, anchor="end", color=MUTED), | |
| text(110, 135, "n=8,192 · m=2 · K=512 · exact q=8,192 + 7,958R", 18, color=MUTED), | |
| ]) | |
| return svg( | |
| "Prediction cost degrades smoothly with exact record quality R", | |
| "The same implementation and instance family spans R=1 through 256; an R=0 control has exactly n queries.", | |
| "\n".join(parts), | |
| ) | |
| def generate_report_assets(root): | |
| images = root / "reports" / "full-reproduction" / "images" | |
| images.mkdir(parents=True, exist_ok=True) | |
| assets = { | |
| "headline.svg": headline(root), | |
| "deterministic-halfspace-scaling.svg": deterministic_and_halfspace(root), | |
| "randomized-rounds.svg": randomized_expectation(root), | |
| "lower-bound-certificate.svg": lower_bound(root), | |
| "prediction-quality.svg": prediction_quality(root), | |
| } | |
| for name, content in assets.items(): | |
| path = images / name | |
| path.write_text(content + "\n") | |
| encoded = base64.b64encode(path.read_bytes()).decode() | |
| print(f"REPORT_ASSET_BASE64 {name} {encoded}") | |
| print(json.dumps({"report_assets": sorted(assets), "status": "VERIFIED"}, sort_keys=True)) | |
| return sorted(assets) | |