| """Deterministic model-vs-execution diagnostic; no sampled TV estimators.""" |
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import math |
| import time |
| from fractions import Fraction |
| from pathlib import Path |
|
|
| import numpy as np |
| from scipy.stats import binom |
|
|
|
|
| def binomial_tv(n: int, p: float, q: float) -> float: |
| """Exact finite distribution identity evaluated by double-precision CDFs. |
| |
| The likelihood ratio is monotone; CDF difference at its crossing gives TV. |
| Neighbor candidates protect against floating-point rounding at a tie. |
| This is not an interval-arithmetic certificate. |
| """ |
| if p == q or n == 0: |
| return 0.0 |
| p, q = sorted((p, q)) |
| difference = q - p |
| log_yes = math.log1p(difference / p) |
| log_no = math.log1p(-difference / (1 - p)) |
| slope = log_yes - log_no |
| crossing = -n * log_no / slope |
| k = math.floor(crossing) |
| candidates = np.array([max(-1, min(n, k + d)) for d in (-1, 0, 1)]) |
| return float(np.max(binom.cdf(candidates, n, p) - binom.cdf(candidates, n, q))) |
|
|
|
|
| def kl_teacher_to_mixture(n, tau, w, delta, block_size=65536): |
| """Sum all n+1 teacher count atoms; no intentional tail truncation.""" |
| total = 0.0 |
| mass = 0.0 |
| terms_abs = 0.0 |
| log_yes = math.log1p(delta / tau) |
| log_no = math.log1p(-delta / (1 - tau)) |
| for start in range(0, n + 1, block_size): |
| k = np.arange(start, min(start + block_size, n + 1)) |
| prob = binom.pmf(k, n, tau) |
| log_lr = k * log_yes + (n - k) * log_no |
| log_mix_lr = np.logaddexp(math.log1p(-w), math.log(w) + log_lr) |
| terms = -prob * log_mix_lr |
| total += float(np.sum(terms, dtype=np.float64)) |
| terms_abs += float(np.sum(abs(terms), dtype=np.float64)) |
| mass += float(np.sum(prob, dtype=np.float64)) |
| residual = abs(mass - 1) |
| if residual > 2e-8 or total < -1e-10 or total > -math.log1p(-w) + 1e-8: |
| raise ArithmeticError((n, total, residual)) |
| return {"kl": total, "teacher_mass_residual": residual, |
| "absolute_summands": terms_abs, "evaluated_atoms": n + 1} |
|
|
|
|
| def validate(): |
| worst_cdf = 0.0 |
| cases = 0 |
| for n in (1, 2, 4, 16, 64, 257): |
| for p, q in ((.25,.5),(.25,.28125),(.25,.250001),(.1,.8)): |
| k = np.arange(n + 1) |
| brute = .5 * np.sum(abs(binom.pmf(k,n,p) - binom.pmf(k,n,q))) |
| error = abs(binomial_tv(n,p,q) - brute) |
| worst_cdf = max(worst_cdf, error) |
| assert error < 2e-12, (n,p,q,error) |
| cases += 1 |
| |
| worst_kl = 0.0 |
| for n in range(1, 9): |
| tau, w, delta = Fraction(1,4), Fraction(1,8), Fraction(1,4) |
| expected = 0.0 |
| for k in range(n + 1): |
| p = Fraction(math.comb(n,k)) * tau**k * (1-tau)**(n-k) |
| r = (1-w)*p + w*math.comb(n,k)*(tau+delta)**k*(1-tau-delta)**(n-k) |
| expected += float(p) * math.log(float(p/r)) |
| observed = kl_teacher_to_mixture(n,float(tau),float(w),float(delta))["kl"] |
| worst_kl = max(worst_kl, abs(expected-observed)) |
| assert worst_kl < 2e-12 |
| return {"status":"PASS", "cdf_vs_pmf_cases":cases, |
| "cdf_vs_pmf_max_error":worst_cdf, |
| "rational_mass_kl_cases":8, "rational_mass_kl_max_error":worst_kl} |
|
|
|
|
| def run(config): |
| started = time.monotonic() |
| validation = validate() |
| records = [] |
| for exponent in config["exponents"]: |
| n = 2**exponent |
| scale = (n/config["reference_n"])**(-config["decay_exponent"]) |
| tau = config["tau"] |
| w, delta = config["w0"]*scale, config["delta0"]*scale |
| stats = kl_teacher_to_mixture(n,tau,w,delta,config["block_size"]) |
| records.append({"n":n,"tau":tau,"w":w,"delta":delta, |
| "kl":stats["kl"],"kl_upper_bound":-math.log1p(-w), |
| "model_tv":w*binomial_tv(n,tau,tau+delta), |
| "execution_tv":binomial_tv(n,tau,tau+w*delta), |
| "head_tv_upper_bound":delta, |
| "execution_hoeffding_lower_bound":max(0.0,1-2*math.exp(-n*(w*delta)**2/2)), |
| "teacher_mass_residual":stats["teacher_mass_residual"], |
| "evaluated_atoms":stats["evaluated_atoms"]}) |
| print(f"E1 n={n} KL={stats['kl']:.6g} outputTV={records[-1]['execution_tv']:.6g}",flush=True) |
| return {"experiment":"e1_model_execution","validation":validation, |
| "records":records,"runtime_seconds":time.monotonic()-started, |
| "metadata":{"method":"Full finite sums for KL; monotone-likelihood-ratio binomial CDF identity for TV", |
| "error_accounting":"No intentional truncation. Double precision, not rigorous interval bounds; full teacher mass residual recorded.", |
| "policy":"all A, then all B; fixed schedule, not all-policy optimum", |
| "full_tv_justification":"Both laws have independent fair A and iid mismatches; count is sufficient for their likelihood ratio.", |
| "head_error":"delta is a uniform upper bound, not measured worst-case equality"}} |
|
|
|
|
| if __name__ == "__main__": |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--config", type=Path, required=True) |
| parser.add_argument("--output", type=Path, required=True) |
| args = parser.parse_args() |
| result = run(json.loads(args.config.read_text())["e1"]) |
| args.output.parent.mkdir(parents=True, exist_ok=True) |
| args.output.write_text(json.dumps(result, indent=2, allow_nan=False)+"\n") |
|
|
