| |
| """Deterministic three-round self-generated-pilot experiment. |
| |
| First reveal all fair representative bits. Next reveal a uniformly random, |
| unrecorded pilot subset of c partner bits, then reveal all remaining partners. |
| Every head is frozen at the beginning of its batch. A hidden uniform subset |
| makes the output exchangeable, so mismatch-count TV equals full-output TV. |
| All calculations below are floating-point finite sums, not proof certificates. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| from fractions import Fraction |
| from itertools import combinations, product |
| import json |
| import math |
| from pathlib import Path |
| import platform |
| import time |
|
|
| import numpy as np |
| import scipy |
| from scipy.special import logsumexp |
| from scipy.stats import binom |
|
|
|
|
| DEFAULTS = { |
| "n_values": [64, 256, 1024, 4096], |
| "tau": 0.25, |
| "w": 0.125, |
| "delta": 0.25, |
| "lambda": 0.2, |
| "logspace_count": 12, |
| "block_size": 64, |
| } |
|
|
|
|
| def make_models(tau: float, w: float, delta: float, lam: float) -> dict: |
| if not (0 < tau < 1 and 0 < w < 1 and 0 < delta < 1 - tau): |
| raise ValueError("Require 0 < tau,w < 1 and 0 < delta < 1-tau") |
| if not 0 < lam <= 1: |
| raise ValueError("Require 0 < lambda <= 1") |
| small_delta = delta * (w / 2) * lam |
| specifications = { |
| "single": ([1 - w, w], [tau, tau + delta]), |
| "ladder": ([1 - w, w / 2, w / 2], |
| [tau, tau + delta, tau + small_delta]), |
| "drift_matched_single": ([1 - w, w], |
| [tau, tau + (delta + small_delta) / 2]), |
| } |
| return { |
| name: {"weights": weights, "probs": probs, |
| "initial_drift": float(np.dot(weights, probs) - tau)} |
| for name, (weights, probs) in specifications.items() |
| } |
|
|
|
|
| def posterior_table(c: int, weights, probs): |
| """Mixture posterior given c completed pairs with m mismatches.""" |
| m = np.arange(c + 1, dtype=float) |
| probs = np.asarray(probs, dtype=float) |
| log_post = ( |
| np.log(np.asarray(weights, dtype=float))[None, :] |
| + m[:, None] * np.log(probs)[None, :] |
| + (c - m[:, None]) * np.log1p(-probs)[None, :] |
| ) |
| log_post -= logsumexp(log_post, axis=1, keepdims=True) |
| posterior = np.exp(log_post) |
| return posterior, posterior @ probs |
|
|
|
|
| def pilot_output(n: int, c: int, weights, probs, block_size: int = 64): |
| """Full deterministic count law; no deliberate probability-tail pruning.""" |
| if not 0 <= c <= n: |
| raise ValueError("Pilot size must be between zero and n") |
| p0 = float(np.dot(weights, probs)) |
| pilot_pmf = binom.pmf(np.arange(c + 1), c, p0) |
| posterior, heads = posterior_table(c, weights, probs) |
| if c == n: |
| return pilot_pmf.copy(), pilot_pmf, posterior, heads |
| tail_n = n - c |
| tail_counts = np.arange(tail_n + 1) |
| q = np.zeros(n + 1) |
| for start in range(0, c + 1, block_size): |
| stop = min(c + 1, start + block_size) |
| conditional = binom.pmf(tail_counts[None, :], tail_n, |
| heads[start:stop, None]) |
| conditional *= pilot_pmf[start:stop, None] |
| for row, m in enumerate(range(start, stop)): |
| q[m:m + tail_n + 1] += conditional[row] |
| return q, pilot_pmf, posterior, heads |
|
|
|
|
| def model_metrics(n: int, tau: float, weights, probs) -> dict: |
| counts = np.arange(n + 1, dtype=float) |
| teacher = binom.pmf(counts, n, tau) |
| probabilities = np.asarray(probs, dtype=float) |
| weights = np.asarray(weights, dtype=float) |
| log_ratios = ( |
| counts[:, None] * np.log(probabilities / tau)[None, :] |
| + (n - counts[:, None]) |
| * np.log((1 - probabilities) / (1 - tau))[None, :] |
| ) |
| kl_terms = -logsumexp(np.log(weights)[None, :] + log_ratios, axis=1) |
| actual_kl = float(np.dot(teacher, kl_terms)) |
| model_pmf = sum(float(weight) * binom.pmf(counts, n, float(prob)) |
| for weight, prob in zip(weights, probabilities)) |
| return { |
| "actual_kl": actual_kl, |
| "kl_upper_bound": float(-np.log(weights[0])), |
| "model_tv": float(np.abs(model_pmf - teacher).sum() / 2), |
| "teacher_mass_residual": float(abs(teacher.sum() - 1)), |
| "model_mass_residual": float(abs(model_pmf.sum() - 1)), |
| } |
|
|
|
|
| def weighted_quantiles(values, weights, quantiles=(0.1, 0.5, 0.9)) -> list: |
| order = np.argsort(values, kind="stable") |
| values = np.asarray(values)[order] |
| cumulative = np.cumsum(np.asarray(weights)[order]) |
| cumulative /= cumulative[-1] |
| return [float(values[min(len(values) - 1, |
| np.searchsorted(cumulative, q, side="left"))]) |
| for q in quantiles] |
|
|
|
|
| def pilot_sizes(n: int, logspace_count: int) -> list[int]: |
| if n < 1: |
| raise ValueError("n must be a positive integer") |
| sizes = {0, n} |
| if n > 1: |
| sizes.update(round(x) for x in np.geomspace(1, n - 1, logspace_count)) |
| sizes.update(round(x) for x in (n ** 0.25, np.sqrt(n), n ** 0.75, n / 2)) |
| return sorted(c for c in sizes if 0 <= c <= n) |
|
|
|
|
| def summarize_case(n, c, tau, weights, probs, block_size=64): |
| q, pilot_pmf, posterior, heads = pilot_output(n, c, weights, probs, block_size) |
| teacher = binom.pmf(np.arange(n + 1), n, tau) |
| drift = heads - tau |
| initial_drift = float(np.dot(weights, probs) - tau) |
| quantiles = weighted_quantiles(drift, pilot_pmf) |
| statistics = { |
| "n": n, |
| "c": c, |
| "tv": float(np.abs(q - teacher).sum() / 2), |
| "normalization_residual": float(abs(q.sum() - 1)), |
| "pilot_mass_residual": float(abs(pilot_pmf.sum() - 1)), |
| "posterior_row_mass_residual": float(np.max(abs(posterior.sum(axis=1) - 1))), |
| "posterior_mean_weights": (pilot_pmf @ posterior).tolist(), |
| "drift_quantiles": dict(zip(("q10", "q50", "q90"), quantiles)), |
| "mean_drift": float(np.dot(pilot_pmf, drift)), |
| "prob_drift_gt_half_initial": float(pilot_pmf[drift > initial_drift / 2].sum()), |
| "initial_drift": initial_drift, |
| "pilot_p0": float(np.dot(weights, probs)), |
| } |
| diagnostic = { |
| "n": n, "c": c, "pilot_m": list(range(c + 1)), |
| "pilot_pmf": pilot_pmf.tolist(), |
| "posterior": posterior.tolist(), |
| "heads": heads.tolist(), "drift": drift.tolist(), |
| "output_count_pmf": q.tolist(), "teacher_count_pmf": teacher.tolist(), |
| } |
| return statistics, diagnostic |
|
|
|
|
| def validate() -> dict: |
| """Independent rational full-label check, averaged over every pilot subset. |
| |
| Each literal output (A,B) is summed over uniformly random subsets J. |
| Conditional heads here use direct rational likelihood products, whereas the |
| production count calculation uses floating-point log posterior updates. |
| """ |
| models = make_models(0.25, 0.125, 0.25, 0.2) |
| tau = Fraction(1, 4) |
| max_atom_residual = 0.0 |
| max_tv_residual = 0.0 |
| max_mass_residual = 0.0 |
| literal_atom_checks = 0 |
| case_count = 0 |
| for model in models.values(): |
| weights = [Fraction(str(x)) for x in model["weights"]] |
| probs = [Fraction(str(x)) for x in model["probs"]] |
| p0 = sum(w * p for w, p in zip(weights, probs)) |
| for n in range(1, 5): |
| for c in range(n + 1): |
| q, _, _, _ = pilot_output(n, c, model["weights"], model["probs"]) |
| subsets = tuple(combinations(range(n), c)) |
| full_tv = Fraction(0) |
| full_mass = Fraction(0) |
| for a in product((0, 1), repeat=n): |
| for b in product((0, 1), repeat=n): |
| e = tuple(x ^ y for x, y in zip(a, b)) |
| s = sum(e) |
| output_probability = Fraction(0) |
| for subset in subsets: |
| m = sum(e[i] for i in subset) |
| likelihoods = [w * p ** m * (1 - p) ** (c - m) |
| for w, p in zip(weights, probs)] |
| p_head = sum(l * p for l, p in zip(likelihoods, probs)) / sum(likelihoods) |
| output_probability += ( |
| p0 ** m * (1 - p0) ** (c - m) |
| * p_head ** (s - m) |
| * (1 - p_head) ** (n - c - s + m) |
| ) / len(subsets) |
| output_probability /= 2 ** n |
| teacher_probability = tau ** s * (1 - tau) ** (n - s) / 2 ** n |
| full_mass += output_probability |
| full_tv += abs(output_probability - teacher_probability) / 2 |
| count_atom_probability = float(q[s]) / math.comb(n, s) / 2 ** n |
| max_atom_residual = max(max_atom_residual, |
| abs(float(output_probability) - count_atom_probability)) |
| literal_atom_checks += 1 |
| count_tv = np.abs(q - binom.pmf(np.arange(n + 1), n, float(tau))).sum() / 2 |
| max_tv_residual = max(max_tv_residual, abs(float(full_tv) - count_tv)) |
| max_mass_residual = max(max_mass_residual, abs(float(full_mass) - 1)) |
| assert full_mass == 1 |
| case_count += 1 |
| |
| endpoint_residual = 0.0 |
| for model in models.values(): |
| for n in (1, 7, 32): |
| reference = binom.pmf(np.arange(n + 1), n, |
| np.dot(model["weights"], model["probs"])) |
| for c in (0, n): |
| q, _, _, _ = pilot_output(n, c, model["weights"], model["probs"]) |
| endpoint_residual = max(endpoint_residual, float(np.max(abs(q - reference)))) |
| tolerance = 2e-12 |
| assert max_atom_residual < tolerance, max_atom_residual |
| assert max_tv_residual < tolerance, max_tv_residual |
| assert endpoint_residual < tolerance, endpoint_residual |
| independent_reference_tvs = { |
| "single": 0.05413154766773641, |
| "ladder": 0.027308808315495564, |
| "drift_matched_single": 0.027628599041908977, |
| } |
| reference_cases = {} |
| for name, model in models.items(): |
| stats, _ = summarize_case(4, 2, 0.25, model["weights"], model["probs"]) |
| assert abs(stats["tv"] - independent_reference_tvs[name]) < tolerance |
| reference_cases[name] = stats |
| return { |
| "status": "passed", "cases": case_count, |
| "literal_atom_checks": literal_atom_checks, |
| "max_atom_residual": max_atom_residual, |
| "max_tv_residual": max_tv_residual, |
| "max_exact_full_mass_residual": max_mass_residual, |
| "max_endpoint_residual": endpoint_residual, |
| "independent_n4_c2_references": reference_cases, |
| "tolerance": tolerance, |
| "scope": "n=1..4 full labelled laws with rational pilot-subset averaging; not a theorem proof", |
| } |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--config", type=Path) |
| parser.add_argument("--output", type=Path, required=True) |
| parser.add_argument("--validate-only", action="store_true") |
| args = parser.parse_args() |
| config = dict(DEFAULTS) |
| if args.config: |
| document = json.loads(args.config.read_text()) |
| config.update(document.get("e2", {})) |
| if int(config["block_size"]) < 1: |
| raise ValueError("block_size must be positive") |
| start = time.perf_counter() |
| validation = validate() |
| result = { |
| "experiment": "E2_three_round_self_generated_pilot", |
| "metadata": { |
| "config": config, "python": platform.python_version(), |
| "numpy": np.__version__, "scipy": scipy.__version__, |
| "computation": "deterministic full finite sums in float64; no deliberate tail pruning", |
| "pilot_sampling_law": "Binomial(c, sum_j weights_j * probs_j), not teacher sampling", |
| "symmetry": "hidden uniform pilot subset; pair permutations and fair representative bits imply full TV equals count TV", |
| "scope": "specified three-round schedule family, not optimal all-policy error", |
| "numerical_caveat": "normalization residuals are diagnostics, not certified floating-point error bounds; binomial underflow may occur", |
| }, |
| "validation": validation, "models": {}, "model_statistics": [], |
| "records": [], "diagnostics": [], |
| } |
| print(json.dumps({"phase": "validation", **validation}), flush=True) |
| if not args.validate_only: |
| models = make_models(float(config["tau"]), float(config["w"]), |
| float(config["delta"]), float(config["lambda"])) |
| result["models"] = models |
| for n in config["n_values"]: |
| n = int(n) |
| for name, model in models.items(): |
| metrics = model_metrics(n, config["tau"], model["weights"], model["probs"]) |
| result["model_statistics"].append({"model": name, "n": n, **metrics}) |
| for c in pilot_sizes(n, int(config["logspace_count"])): |
| case_start = time.perf_counter() |
| record, diagnostic = summarize_case( |
| n, c, config["tau"], model["weights"], model["probs"], |
| int(config["block_size"])) |
| record.update({"model": name, "runtime_seconds": time.perf_counter() - case_start}) |
| if record["normalization_residual"] > 1e-9: |
| raise ArithmeticError(f"Count normalization failed: {name=}, {n=}, {c=}") |
| result["records"].append(record) |
| if n == 1024 and c == 32: |
| result["diagnostics"].append({"model": name, **diagnostic}) |
| records = [r for r in result["records"] if r["model"] == name and r["n"] == n] |
| best = min(records, key=lambda r: r["tv"]) |
| print(json.dumps({"phase": "grid_progress", "n": n, "model": name, |
| "cases": len(records), "best_grid_c": best["c"], |
| "best_grid_tv": best["tv"], **metrics}), flush=True) |
| result["metadata"]["runtime_seconds"] = time.perf_counter() - start |
| args.output.parent.mkdir(parents=True, exist_ok=True) |
| args.output.write_text(json.dumps(result, indent=2, allow_nan=False) + "\n") |
| print(json.dumps({"phase": "complete", "output": str(args.output), |
| "records": len(result["records"]), |
| "runtime_seconds": result["metadata"]["runtime_seconds"]}), flush=True) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
