from __future__ import annotations import argparse import hashlib import json import math import random from collections import Counter from functools import lru_cache from pathlib import Path from statistics import NormalDist, mean, stdev from typing import Any, Mapping, Sequence from artifact.contracts import ContractError, canonical_sha256, load_json from artifact.schedule import load_tasks, validate_schedule PRECISION_VERSION = "0.2.1-prepilot" PRECISION_SEED = 2026072302 DEFAULT_BASELINES = (0.2, 0.4, 0.6) DEFAULT_TASK_CORRELATIONS = (0.0, 0.3, 0.6) DEFAULT_WITHIN_RUN_PHASE_INCREMENTS = (0.0, 0.2) DEFAULT_EFFECTS = tuple(round(index * 0.05, 2) for index in range(13)) DEFAULT_PHASE_COUNTS = (1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2) NORMAL = NormalDist() def _stable_seed(seed: int, label: str) -> int: digest = hashlib.sha256(f"{seed}:{label}".encode("utf-8")).digest() return int.from_bytes(digest[:8], "big") @lru_cache(maxsize=64) def _normal_cutoff(probability: float) -> float: return NORMAL.inv_cdf(probability) def _quantile(values: Sequence[float], probability: float) -> float: ordered = sorted(float(value) for value in values) if not ordered: raise ValueError("quantile requires values") if len(ordered) == 1: return ordered[0] position = (len(ordered) - 1) * probability lower = math.floor(position) upper = math.ceil(position) if lower == upper: return ordered[lower] fraction = position - lower return ordered[lower] * (1.0 - fraction) + ordered[upper] * fraction def _studentized_task_difference(differences: Sequence[float]) -> float: if not differences: return 0.0 center = mean(differences) if len(differences) < 2: return math.inf if center else 0.0 spread = stdev(differences) if spread == 0: return math.inf if center else 0.0 return center / (spread / math.sqrt(len(differences))) def load_precision_design(root: Path) -> dict[str, Any]: """Derive task phase opportunities from validated frozen study inputs.""" artifact_root = root.resolve() schedule_path = artifact_root / "data" / "schedule.json" if not schedule_path.is_file(): raise ValueError(f"precision schedule is missing: {schedule_path}") try: tasks = load_tasks(artifact_root) schedule = load_json(schedule_path) validate_schedule(schedule, tasks) except (ContractError, ValueError) as exc: raise ValueError(f"precision design inputs are invalid: {exc}") from exc mapping = [ { "task_id": task["task_id"], "scenario": task["scenario"], "phase_count": 1 if task["scenario"] == "premature" else 2, "task_manifest_sha256": task["_manifest_sha256"], } for task in sorted( ( item for item in tasks if item["study_phase"] == "confirmatory" ), key=lambda item: item["task_id"], ) ] phase_shape = Counter(item["phase_count"] for item in mapping) if len(mapping) != 12 or phase_shape != Counter({1: 4, 2: 8}): raise ValueError( "validated confirmatory tasks do not have the frozen 4x1 plus 8x2 phase shape" ) return { "source": "validated_confirmatory_task_manifests_and_schedule", "schedule_sha256": schedule["schedule_sha256"], "task_phase_design_sha256": canonical_sha256(mapping), "tasks": mapping, } def validate_precision_report( report: Mapping[str, Any], design: Mapping[str, Any], ) -> None: """Reject a saved design report that no longer matches frozen study inputs.""" if set(report) != {"precision", "scenarios", "interpretation"}: raise ValueError("precision report has missing or unknown top-level fields") precision = report["precision"] scenarios = report["scenarios"] interpretation = report["interpretation"] if ( not isinstance(precision, Mapping) or not isinstance(scenarios, list) or not isinstance(interpretation, Mapping) ): raise ValueError("precision report has invalid container types") if precision.get("version") != PRECISION_VERSION: raise ValueError("precision report version is stale") if precision.get("phase_design") != design: raise ValueError( "precision report phase design does not match current task manifests and schedule" ) phase_counts = tuple(int(item["phase_count"]) for item in design["tasks"]) expected_counts = { str(key): value for key, value in sorted(Counter(phase_counts).items()) } expected_denominators = [3 * phase_count for phase_count in phase_counts] expected = { "seed": PRECISION_SEED, "clusters": len(phase_counts), "repetitions_per_condition_per_cluster": 3, "task_phase_counts": list(phase_counts), "task_counts_by_phase_count": expected_counts, "phase_opportunities_per_condition": 3 * sum(phase_counts), "task_condition_denominators": expected_denominators, "simulations_per_grid_point": 4_000, "alpha_two_sided": 0.05, "target_power": 0.80, } for key, value in expected.items(): if precision.get(key) != value: raise ValueError(f"precision report {key} differs from the preregistered design") expected_combinations = { (baseline, task_correlation, phase_increment) for baseline in DEFAULT_BASELINES for task_correlation in DEFAULT_TASK_CORRELATIONS for phase_increment in DEFAULT_WITHIN_RUN_PHASE_INCREMENTS } observed_combinations: set[tuple[float, float, float]] = set() for scenario in scenarios: if not isinstance(scenario, Mapping): raise ValueError("precision report contains a non-object scenario") combination = ( float(scenario.get("baseline_risk")), float(scenario.get("task_latent_correlation")), float(scenario.get("within_run_phase_increment")), ) if combination in observed_combinations: raise ValueError("precision report contains a duplicate scenario") observed_combinations.add(combination) curve = scenario.get("power_curve") if not isinstance(curve, list): raise ValueError("precision report scenario has no power curve") observed_effects = [ float(point.get("absolute_risk_reduction")) for point in curve if isinstance(point, Mapping) ] expected_effects = [ float(effect) for effect in DEFAULT_EFFECTS if effect <= combination[0] ] if len(observed_effects) != len(curve) or observed_effects != expected_effects: raise ValueError("precision report power grid differs from the preregistered design") if observed_combinations != expected_combinations: raise ValueError("precision report scenario grid differs from the preregistered design") def validate_saved_precision_inputs( root: Path, output: Path | None = None, ) -> dict[str, Any]: """Cheap lock-time validation of saved precision provenance and design.""" artifact_root = root.resolve() path = output or (artifact_root / "analysis" / "precision.json") resolved = path.resolve() if path.is_absolute() else (artifact_root / path).resolve() try: report = load_json(resolved) except ContractError as exc: raise ValueError(f"saved precision report is invalid: {exc}") from exc design = load_precision_design(artifact_root) validate_precision_report(report, design) return report def _validate_phase_design( phase_counts: Sequence[int], phase_design: Mapping[str, Any] | None, ) -> tuple[tuple[int, ...], dict[str, Any]]: task_phase_counts = tuple(int(value) for value in phase_counts) if phase_design is None: mapping = [ { "task_id": f"task-{index:02d}", "phase_count": phase_count, } for index, phase_count in enumerate(task_phase_counts, 1) ] return task_phase_counts, { "source": "explicit_phase_counts_for_diagnostics", "schedule_sha256": None, "task_phase_design_sha256": canonical_sha256(mapping), "tasks": mapping, } if set(phase_design) != { "source", "schedule_sha256", "task_phase_design_sha256", "tasks", }: raise ValueError("precision phase design has missing or unknown fields") tasks = phase_design["tasks"] if not isinstance(tasks, list) or not tasks: raise ValueError("precision phase design tasks must be a non-empty list") derived = tuple(int(item["phase_count"]) for item in tasks) if task_phase_counts != derived: raise ValueError( "explicit phase counts contradict the validated task phase design" ) if canonical_sha256(tasks) != phase_design["task_phase_design_sha256"]: raise ValueError("precision task phase design digest does not match") return derived, dict(phase_design) def _one_dataset( rng: random.Random, *, phase_counts: Sequence[int], repetitions: int, baseline_risk: float, absolute_reduction: float, task_latent_correlation: float, within_run_phase_increment: float, ) -> tuple[list[float], float]: treatment_risk = max(0.0, baseline_risk - absolute_reduction) control_cutoff = _normal_cutoff(baseline_risk) treatment_cutoff = ( -math.inf if treatment_risk == 0 else _normal_cutoff(treatment_risk) ) task_weight = math.sqrt(task_latent_correlation) run_weight = math.sqrt(within_run_phase_increment) residual_weights = { phase_count: math.sqrt( 1.0 - task_latent_correlation - (within_run_phase_increment if phase_count > 1 else 0.0) ) for phase_count in set(phase_counts) } gaussian = rng.gauss differences: list[float] = [] for phase_count in phase_counts: task_factor = gaussian(0.0, 1.0) if task_weight else 0.0 control_events = 0 treatment_events = 0 for _ in range(repetitions): active_run_weight = run_weight if phase_count > 1 else 0.0 residual_weight = residual_weights[phase_count] control_run_factor = ( gaussian(0.0, 1.0) if active_run_weight else 0.0 ) treatment_run_factor = ( gaussian(0.0, 1.0) if active_run_weight else 0.0 ) for _ in range(phase_count): control_latent = ( task_weight * task_factor + active_run_weight * control_run_factor + residual_weight * gaussian(0.0, 1.0) ) treatment_latent = ( task_weight * task_factor + active_run_weight * treatment_run_factor + residual_weight * gaussian(0.0, 1.0) ) control_events += control_latent <= control_cutoff treatment_events += treatment_latent <= treatment_cutoff opportunities = repetitions * phase_count differences.append( treatment_events / opportunities - control_events / opportunities ) return differences, treatment_risk def simulate_precision( *, phase_counts: Sequence[int] = DEFAULT_PHASE_COUNTS, phase_design: Mapping[str, Any] | None = None, repetitions: int = 3, baselines: Sequence[float] = DEFAULT_BASELINES, task_correlations: Sequence[float] = DEFAULT_TASK_CORRELATIONS, within_run_phase_increments: Sequence[float] = DEFAULT_WITHIN_RUN_PHASE_INCREMENTS, effects: Sequence[float] = DEFAULT_EFFECTS, simulations: int = 4_000, alpha: float = 0.05, target_power: float = 0.80, seed: int = PRECISION_SEED, ) -> dict[str, Any]: """Estimate design precision under an explicit clustered latent-normal model. The empirical null critical value avoids pretending that twelve discrete task differences follow a large-sample normal distribution. The simulation remains an assumption-dependent design diagnostic, not a promise of power. """ task_phase_counts, design_provenance = _validate_phase_design( phase_counts, phase_design, ) if len(task_phase_counts) < 2 or any( value not in {1, 2} for value in task_phase_counts ): raise ValueError( "precision simulation requires at least two tasks with phase count one or two" ) if repetitions < 1 or simulations < 100: raise ValueError( "precision simulation requires >=1 repetition and >=100 simulations" ) if not 0 < alpha < 1 or not 0 < target_power < 1: raise ValueError("alpha and target_power must be between zero and one") if any(not 0 < value < 1 for value in baselines): raise ValueError("baseline risks must be strictly between zero and one") if any(not 0 <= value < 1 for value in task_correlations): raise ValueError("task latent correlations must be in [0, 1)") if any(not 0 <= value < 1 for value in within_run_phase_increments): raise ValueError("within-run phase increments must be in [0, 1)") if any( task_correlation + phase_increment >= 1 for task_correlation in task_correlations for phase_increment in within_run_phase_increments ): raise ValueError( "task correlation plus within-run phase increment must be below one" ) if any(value < 0 for value in effects): raise ValueError("effect sizes must be non-negative") scenarios: list[dict[str, Any]] = [] for baseline in baselines: for task_correlation in task_correlations: for phase_increment in within_run_phase_increments: label = ( f"p={baseline:.6f}:task={task_correlation:.6f}:" f"phase_increment={phase_increment:.6f}:" f"shape={','.join(str(value) for value in task_phase_counts)}" ) null_rng = random.Random(_stable_seed(seed, label + ":null")) null_statistics: list[float] = [] for _ in range(simulations): differences, _ = _one_dataset( null_rng, phase_counts=task_phase_counts, repetitions=repetitions, baseline_risk=baseline, absolute_reduction=0.0, task_latent_correlation=task_correlation, within_run_phase_increment=phase_increment, ) null_statistics.append( abs(_studentized_task_difference(differences)) ) critical = _quantile(null_statistics, 1.0 - alpha) powers: list[dict[str, Any]] = [] for effect in sorted( set(float(value) for value in effects if value <= baseline) ): effect_rng = random.Random( _stable_seed(seed, label + f":effect={effect:.6f}") ) rejected = 0 observed_differences: list[float] = [] for _ in range(simulations): differences, treatment_risk = _one_dataset( effect_rng, phase_counts=task_phase_counts, repetitions=repetitions, baseline_risk=baseline, absolute_reduction=effect, task_latent_correlation=task_correlation, within_run_phase_increment=phase_increment, ) observed_differences.append(mean(differences)) rejected += ( abs(_studentized_task_difference(differences)) > critical ) powers.append( { "absolute_risk_reduction": effect, "treatment_risk": treatment_risk, "estimated_power": rejected / simulations, "mean_observed_risk_difference": mean( observed_differences ), } ) detectable = next( ( item["absolute_risk_reduction"] for item in powers if item["absolute_risk_reduction"] > 0 and item["estimated_power"] >= target_power ), None, ) scenarios.append( { "baseline_risk": baseline, "task_latent_correlation": task_correlation, "within_run_phase_increment": phase_increment, "same_run_phase_latent_correlation": ( task_correlation + phase_increment ), "empirical_two_sided_critical_value": critical, "minimum_grid_effect_at_target_power": detectable, "power_curve": powers, } ) return { "precision": { "version": PRECISION_VERSION, "seed": seed, "clusters": len(task_phase_counts), "repetitions_per_condition_per_cluster": repetitions, "task_phase_counts": list(task_phase_counts), "phase_design": design_provenance, "task_counts_by_phase_count": { str(key): value for key, value in sorted(Counter(task_phase_counts).items()) }, "phase_opportunities_per_condition": repetitions * sum(task_phase_counts), "task_condition_denominators": [ repetitions * phase_count for phase_count in task_phase_counts ], "simulations_per_grid_point": simulations, "alpha_two_sided": alpha, "target_power": target_power, "estimand": "risk(beforedone) - risk(prompt_only)", "model": ( "latent-normal phase-opportunity Bernoulli outcomes with a shared " "task factor, condition-and-repetition-specific run factors for " "two-stage tasks, and phase residuals" ), "test": ( "pool phase opportunities within each task-condition, form twelve " "paired task risk differences, and compare their absolute " "studentized mean with a scenario-specific empirical null critical value" ), }, "scenarios": scenarios, "interpretation": { "grid_definition": ( "The reported MDE is the first tested absolute risk-reduction grid " "point reaching target power; it is not an exact continuous threshold." ), "small_sample_warning": ( "Twelve task clusters provide limited precision. Wide intervals or " "non-significant findings are not evidence of equivalence." ), "scope_warning": ( "Power depends on the simulated baseline phase-opportunity risk, " "latent task correlation, additional within-run phase correlation, " "and paired-outcome model; it does not generalize beyond the frozen " "benchmark suite." ), "correlation_warning": ( "The correlation parameters are Gaussian latent-factor variance " "components, not Bernoulli Pearson correlations. Same-run phase " "latent correlation equals task correlation plus the reported " "within-run increment." ), "repository_dependence_warning": ( "The twelve task clusters come from only three repositories, with " "four tasks per repository. This simulation has no additional " "repository-level factor, so unmodeled within-repository dependence " "can overstate precision; it does not support repository-population " "inference." ), }, } def write_precision(report: dict[str, Any], output: Path) -> None: output.parent.mkdir(parents=True, exist_ok=True) output.write_text( json.dumps(report, ensure_ascii=False, indent=2, sort_keys=True) + "\n", encoding="utf-8", newline="\n", ) def _csv_floats(value: str) -> tuple[float, ...]: return tuple(float(item.strip()) for item in value.split(",") if item.strip()) def _parser() -> argparse.ArgumentParser: parser = argparse.ArgumentParser(description="Simulate BeforeDone study precision") parser.add_argument("--root", type=Path, default=Path.cwd()) parser.add_argument( "--output", type=Path, default=Path("analysis/precision.json"), ) parser.add_argument("--repetitions", type=int, default=3) parser.add_argument("--baselines", type=_csv_floats, default=DEFAULT_BASELINES) parser.add_argument( "--task-correlations", type=_csv_floats, default=DEFAULT_TASK_CORRELATIONS, ) parser.add_argument( "--within-run-phase-increments", type=_csv_floats, default=DEFAULT_WITHIN_RUN_PHASE_INCREMENTS, ) parser.add_argument("--effects", type=_csv_floats, default=DEFAULT_EFFECTS) parser.add_argument("--simulations", type=int, default=4_000) parser.add_argument("--alpha", type=float, default=0.05) parser.add_argument("--target-power", type=float, default=0.80) parser.add_argument("--seed", type=int, default=PRECISION_SEED) parser.add_argument( "--verify", action="store_true", help="recompute and require byte-identical output instead of writing it", ) return parser def main(argv: Sequence[str] | None = None) -> int: args = _parser().parse_args(argv) root = args.root.resolve() try: design = load_precision_design(root) phase_counts = tuple(item["phase_count"] for item in design["tasks"]) report = simulate_precision( phase_counts=phase_counts, phase_design=design, repetitions=args.repetitions, baselines=args.baselines, task_correlations=args.task_correlations, within_run_phase_increments=args.within_run_phase_increments, effects=args.effects, simulations=args.simulations, alpha=args.alpha, target_power=args.target_power, seed=args.seed, ) except ValueError as exc: print(f"precision simulation failed: {exc}") return 1 output = ( args.output.resolve() if args.output.is_absolute() else (root / args.output).resolve() ) if args.verify: if not output.is_file(): print(f"precision verification failed: output is missing: {output}") return 1 expected = json.dumps( report, ensure_ascii=False, indent=2, sort_keys=True, ) + "\n" try: observed = output.read_text(encoding="utf-8") except (OSError, UnicodeError) as exc: print(f"precision verification failed: cannot read output: {exc}") return 1 if observed != expected: print( "precision verification failed: saved report is not the " "deterministic result for current inputs" ) return 1 print(f"verified {output}") return 0 write_precision(report, output) print(f"wrote {output}") return 0 if __name__ == "__main__": raise SystemExit(main())