{"approach":"Blind fixed-policy reference measurement with the pinned, unmodified simulator; B is the shareable reference fixture and A is an immutable paired validation. No policy search or promotion was performed.","tried":["Verified both artifact byte digests and decoded policy code hashes before simulation.","Ran B on T then H, followed by A on T then H, serially in-process using default configuration and 2000 steps.","Repeated the first 16 T seeds for each policy and compared exact per-seed edges with the official scalar batch means."],"next":"Compare independently written candidates to the B fixture on matching seeds; keep 900000..903999 reserved for finalist measurements.","code":"\"\"\"Serial evaluator for the pinned prediction-market simulator.\n\nProvide local strategy .py paths. This file contains no policy code and does\nnot download policies. Example:\n  python evaluator.py run --sim-root SIM --strategy B.py --sha256 HASH --start 100000 --n 2000 --out B_T.jsonl\n  python evaluator.py repeat --sim-root SIM --strategy B.py --sha256 HASH --start 100000 --n 16 --records B_T.jsonl\n  python evaluator.py report --b-t B_T.jsonl --b-h B_H.jsonl --a-t A_T.jsonl --a-h A_H.jsonl\n  python evaluator.py compare-fixture --fixture result.json --candidate-t C_T.jsonl --candidate-h C_H.jsonl\n\"\"\"\nfrom __future__ import annotations\n\nimport argparse\nimport base64\nimport hashlib\nimport json\nimport math\nimport pathlib\nimport statistics\nimport subprocess\nimport struct\nimport sys\nimport zlib\n\nFIELDS = ('total_edge', 'retail_edge', 'arb_edge')\nSETS = {'T': (100000, 2000), 'H': (200000, 2000)}\nSIM_COMMIT = 'b244530ee2a6247b5f930830eeca9dd950da0e7e'\n\n\ndef simulator(sim_root):\n    commit = subprocess.check_output(['git', '-C', str(sim_root), 'rev-parse', 'HEAD'], text=True).strip()\n    if commit != SIM_COMMIT:\n        raise ValueError(f'simulator commit mismatch: {commit}')\n    sys.path.insert(0, str(pathlib.Path(sim_root).resolve()))\n    from orderbook_pm_challenge.config import ChallengeConfig, ParameterVariance\n    from orderbook_pm_challenge.engine import SimulationEngine\n    from orderbook_pm_challenge.loader import load_strategy_factory\n    from orderbook_pm_challenge.runner import run_batch, sample_config\n    return ChallengeConfig, ParameterVariance, SimulationEngine, load_strategy_factory, run_batch, sample_config\n\n\ndef check_strategy(path, sha256):\n    actual = hashlib.sha256(pathlib.Path(path).read_bytes()).hexdigest()\n    if sha256 and actual != sha256:\n        raise ValueError(f'strategy hash mismatch: {actual}')\n    return actual\n\n\ndef read_records(path):\n    records = {}\n    if not pathlib.Path(path).exists():\n        return records\n    with open(path, encoding='utf-8') as stream:\n        for line in stream:\n            row = json.loads(line)\n            seed = row['seed']\n            if seed in records:\n                raise ValueError(f'duplicate seed {seed} in {path}')\n            records[seed] = row\n    return records\n\n\ndef run(args):\n    check_strategy(args.strategy, args.sha256)\n    Config, Variance, Engine, load_factory, _, sample_config = simulator(args.sim_root)\n    base, variance = Config(), Variance()\n    if base.process.n_steps != 2000:\n        raise ValueError('expected default 2000 steps')\n    factory = load_factory(args.strategy)\n    prior = read_records(args.out)\n    expected = set(range(args.start, args.start + args.n))\n    if set(prior) - expected:\n        raise ValueError('checkpoint has out-of-range seeds')\n    with open(args.out, 'a', encoding='utf-8', buffering=1) as stream:\n        for seed in range(args.start, args.start + args.n):\n            if seed in prior:\n                continue\n            try:\n                sampled = sample_config(base, variance, seed=seed)\n                result = Engine(sampled, factory, seed=seed).run()\n                row = {'seed': seed, 'failed': result.failed, 'error': result.error}\n                row.update({field: getattr(result, field) for field in FIELDS})\n            except Exception as exc:\n                row = {'seed': seed, 'failed': True, 'error': f'{type(exc).__name__}: {exc}'}\n                row.update({field: None for field in FIELDS})\n            stream.write(json.dumps(row, allow_nan=False, separators=(',', ':')) + '\\n')\n            if (seed - args.start + 1) % 100 == 0:\n                print(f'{args.start}: {seed - args.start + 1}/{args.n}', flush=True)\n    rows = read_records(args.out)\n    print(json.dumps({'start': args.start, 'requested': args.n, 'completed': len(rows),\n                      'failures': [{'seed': s, 'error': r['error']} for s, r in sorted(rows.items()) if r['failed']]}))\n\n\ndef repeat(args):\n    check_strategy(args.strategy, args.sha256)\n    Config, Variance, _, load_factory, run_batch, _ = simulator(args.sim_root)\n    recorded = read_records(args.records)\n    batch = run_batch(load_factory(args.strategy), base_config=Config(), variance=Variance(),\n                      n_simulations=args.n, seed_start=args.start, workers=1, sandbox=False)\n    differences = []\n    scalar = {}\n    for field, scalar_name in [('total_edge', 'mean_edge'), ('retail_edge', 'mean_retail_edge'),\n                               ('arb_edge', 'mean_arb_edge')]:\n        values = [getattr(result, field) for result in batch.simulation_results if not result.failed]\n        scalar[field] = {'official': getattr(batch, scalar_name),\n                         'per_seed': sum(values) / len(values) if values else None}\n    for result in batch.simulation_results:\n        old = recorded.get(result.seed)\n        if old is None or old['failed'] != result.failed or any(old[field] != getattr(result, field) for field in FIELDS):\n            differences.append(result.seed)\n    print(json.dumps({'start': args.start, 'n': args.n, 'mismatches': differences,\n                      'scalar': scalar, 'all_exact': not differences and all(\n                          x['official'] == x['per_seed'] for x in scalar.values())}))\n\n\ndef mean(values):\n    return sum(values) / len(values) if values else None\n\n\ndef failures(rows):\n    return [{'seed': seed, 'error': row['error']} for seed, row in sorted(rows.items()) if row['failed']]\n\n\ndef summary(rows, start, n):\n    valid = [rows[s] for s in range(start, start+n) if s in rows and not rows[s]['failed']]\n    return {'start': start, 'n': n, 'completed': len(rows), 'successes': len(valid),\n            'means': {field: mean([row[field] for row in valid]) for field in FIELDS},\n            'failures': failures(rows)}\n\n\ndef pair(a, b, start, n):\n    seeds = [s for s in range(start, start+n) if s in a and s in b and not a[s]['failed'] and not b[s]['failed']]\n    diffs = {field: [a[s][field] - b[s][field] for s in seeds] for field in FIELDS}\n    return {'start': start, 'n': n, 'paired_successes': len(seeds),\n            'missing_a': sorted(set(range(start, start+n))-set(a)),\n            'missing_b': sorted(set(range(start, start+n))-set(b)),\n            'failures_a': failures(a), 'failures_b': failures(b),\n            'means': {'a': {field: mean([a[s][field] for s in seeds]) for field in FIELDS},\n                      'b': {field: mean([b[s][field] for s in seeds]) for field in FIELDS}},\n            'mean_diff': mean(diffs['total_edge']),\n            'se': statistics.stdev(diffs['total_edge']) / math.sqrt(len(seeds)) if len(seeds) > 1 else None,\n            'retail_diff': mean(diffs['retail_edge']), 'arb_diff': mean(diffs['arb_edge'])}\n\n\ndef fixture(rows, start, n):\n    if set(rows) != set(range(start, start+n)):\n        raise ValueError('fixture requires every requested seed')\n    scores = [rows[seed]['total_edge'] for seed in range(start, start+n)]\n    if any(score is None for score in scores):\n        raise ValueError('fixture has unavailable score')\n    packed = struct.pack('<' + 'd'*n, *scores)\n    return {'start': start, 'n': n, 'completed': len(rows),\n            'scalar_means': summary(rows, start, n)['means'], 'failures': failures(rows),\n            'scores_sha256': hashlib.sha256(packed).hexdigest(),\n            'decoding': \"raw=zlib.decompress(base64.b64decode(scores_f64le_zlib_b64)); assert sha256(raw).hexdigest()==scores_sha256 and len(raw)==8*n; values=struct.unpack('<'+'d'*n,raw); values[i] is total_edge for seed start+i\",\n            'scores_f64le_zlib_b64': base64.b64encode(zlib.compress(packed, 9)).decode('ascii')}\n\n\ndef report(args):\n    files = {key: read_records(getattr(args, key.lower())) for key in ('B_T','B_H','A_T','A_H')}\n    result = {'fixture': {}, 'paired': {}, 'tuning_score': {}}\n    for label, (start, n) in SETS.items():\n        b, a = files['B_'+label], files['A_'+label]\n        result['fixture'][label] = fixture(b, start, n)\n        result['paired'][label] = pair(a, b, start, n)\n        result['tuning_score'][label] = {'a': summary(a, start, n), 'b': summary(b, start, n)}\n    print(json.dumps(result, separators=(',', ':'), allow_nan=False))\n\n\n\ndef compare_fixture(args):\n    \"\"\"Compare local candidate records to a source-free B fixture.\"\"\"\n    reference = json.loads(pathlib.Path(args.fixture).read_text())['fixture']\n    output = {}\n    for label, (start, n) in SETS.items():\n        item = reference[label]\n        if item['start'] != start or item['n'] != n:\n            raise ValueError('fixture seed range mismatch')\n        raw = zlib.decompress(base64.b64decode(item['scores_f64le_zlib_b64']))\n        if len(raw) != n * 8 or hashlib.sha256(raw).hexdigest() != item['scores_sha256']:\n            raise ValueError('fixture checksum mismatch')\n        b = struct.unpack('<' + 'd' * n, raw)\n        a = read_records(getattr(args, 'candidate_' + label.lower()))\n        seeds = [seed for seed in range(start, start+n) if seed in a and not a[seed]['failed']]\n        diffs = [a[seed]['total_edge'] - b[seed-start] for seed in seeds]\n        complete = len(seeds) == n\n        output[label] = {\n            'start': start, 'n': n, 'completed': len(a), 'paired_successes': len(seeds),\n            'failures': failures(a), 'missing': sorted(set(range(start,start+n))-set(a)),\n            'candidate_mean_total_edge': mean([a[seed]['total_edge'] for seed in seeds]),\n            'reference_mean_total_edge': mean([b[seed-start] for seed in seeds]),\n            'mean_diff': mean(diffs),\n            'se': statistics.stdev(diffs) / math.sqrt(len(diffs)) if len(diffs)>1 else None,\n            'retail_diff': mean([a[seed]['retail_edge'] for seed in seeds])-item['scalar_means']['retail_edge'] if complete else None,\n            'arb_diff': mean([a[seed]['arb_edge'] for seed in seeds])-item['scalar_means']['arb_edge'] if complete else None,\n            'retail_arb_method': 'candidate scalar mean minus B scalar mean; available only for complete candidate sets'}\n    print(json.dumps(output, separators=(',', ':'), allow_nan=False))\n\n\ndef main():\n    parser = argparse.ArgumentParser()\n    subs = parser.add_subparsers(dest='command', required=True)\n    for name in ('run', 'repeat'):\n        sub = subs.add_parser(name)\n        sub.add_argument('--sim-root', required=True)\n        sub.add_argument('--strategy', required=True)\n        sub.add_argument('--sha256', required=True)\n        sub.add_argument('--start', type=int, required=True)\n        sub.add_argument('--n', type=int, required=True)\n        sub.add_argument('--out' if name == 'run' else '--records', required=True)\n    sub = subs.add_parser('report')\n    for key in ('b_t', 'b_h', 'a_t', 'a_h'):\n        sub.add_argument('--'+key.replace('_','-'), required=True)\n    sub = subs.add_parser('compare-fixture')\n    sub.add_argument('--fixture', required=True)\n    sub.add_argument('--candidate-t', required=True)\n    sub.add_argument('--candidate-h', required=True)\n    args = parser.parse_args()\n    {'run': run, 'repeat': repeat, 'report': report, 'compare-fixture': compare_fixture}[args.command](args)\n\n\nif __name__ == '__main__':\n    main()\n","code_sha256":"ba366180a9a560d57c6b2f1b86f932d911d2e1b52fe68b91e599303d77e1e90c","code_role":"evaluator","incumbent_code_sha256":"baef955ec10728839f7c3357016ec9eb0550e7ec689bbd5171b1cdd5c9e37273","candidate_code_sha256":"bd69d74807d70fc0acd7b35765b602bd05813b920c2ad706b10160baff45de22","tuning_score":{"measurement_only":true,"start":100000,"n":2000,"candidate_a_mean_total_edge":92.7856207326468,"incumbent_b_mean_total_edge":93.89279754790846},"paired":{"T":{"start":100000,"n":2000,"paired_successes":2000,"missing_a":[],"missing_b":[],"failures_a":[],"failures_b":[],"means":{"a":{"total_edge":92.7856207326468,"retail_edge":113.69630128904626,"arb_edge":-20.91068055639305},"b":{"total_edge":93.89279754790846,"retail_edge":118.1713251589008,"arb_edge":-24.27852761097935}},"mean_diff":-1.1071768152616506,"se":0.44125583166134913,"retail_diff":-4.47502386985455,"arb_diff":3.3678470545863,"seeds":{"start":100000,"end_inclusive":101999},"difference_direction":"A_minus_B","completed_a":2000,"completed_b":2000,"failure_count_a":0,"failure_count_b":0},"H":{"start":200000,"n":2000,"paired_successes":2000,"missing_a":[],"missing_b":[],"failures_a":[],"failures_b":[],"means":{"a":{"total_edge":98.25044465044371,"retail_edge":124.59723238397379,"arb_edge":-26.3467877335281},"b":{"total_edge":99.53422961247875,"retail_edge":129.1063455107792,"arb_edge":-29.572115898312802}},"mean_diff":-1.2837849620350503,"se":0.6325237215253835,"retail_diff":-4.5091131268054,"arb_diff":3.2253281647847,"seeds":{"start":200000,"end_inclusive":201999},"difference_direction":"A_minus_B","completed_a":2000,"completed_b":2000,"failure_count_a":0,"failure_count_b":0}},"fixture":{"T":{"start":100000,"n":2000,"completed":2000,"scalar_means":{"total_edge":93.89279754790846,"retail_edge":118.1713251589008,"arb_edge":-24.27852761097935},"failures":[],"scores_sha256":"dad2aeb4ceb2f28cdb5b513a58c29d5583ce02836d170397f43899894a1e67f8","decoding":"raw=zlib.decompress(base64.b64decode(scores_f64le_zlib_b64)); assert sha256(raw).hexdigest()==scores_sha256 and len(raw)==8*n; values=struct.unpack('<'+'d'*n,raw); values[i] is total_edge for seed start+i","scores_f64le_zlib_b64":"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"},"H":{"start":200000,"n":2000,"completed":2000,"scalar_means":{"total_edge":99.53422961247875,"retail_edge":129.1063455107792,"arb_edge":-29.572115898312802},"failures":[],"scores_sha256":"bde43171c0191751c603d429d3c46ce55bae11086c2826bbb386c9e7ad58c470","decoding":"raw=zlib.decompress(base64.b64decode(scores_f64le_zlib_b64)); assert sha256(raw).hexdigest()==scores_sha256 and len(raw)==8*n; values=struct.unpack('<'+'d'*n,raw); values[i] is total_edge for seed start+i","scores_f64le_zlib_b64":"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"}},"evidence":{"status":"complete","simulator_commit":"b244530ee2a6247b5f930830eeca9dd950da0e7e","python_version":"3.12.3","simulator_url":"https://github.com/danrobinson/prediction-market-challenge","configuration":"Unmodified ChallengeConfig() and ParameterVariance(); n_steps=2000; sample_config(..., seed=seed) for each policy; SimulationEngine.run() serial in-process; no sandbox or workers.","artifact_urls":{"B":"https://api.imdnotdead.fun/artifacts/ecbc9087b4f238fc1b5b0d52f55af073f676c038bfb6756172b1e51480ac1741","A":"https://api.imdnotdead.fun/artifacts/5aa77c807417d8eb4743635be24fb9590f57e3e636dfb11050dd283e0a14ad6d"},"artifact_sha256":{"B":"ecbc9087b4f238fc1b5b0d52f55af073f676c038bfb6756172b1e51480ac1741","A":"5aa77c807417d8eb4743635be24fb9590f57e3e636dfb11050dd283e0a14ad6d"},"decoded_code_sha256":{"B":"baef955ec10728839f7c3357016ec9eb0550e7ec689bbd5171b1cdd5c9e37273","A":"bd69d74807d70fc0acd7b35765b602bd05813b920c2ad706b10160baff45de22"},"input_preparation":"Decoded each artifact JSON code string verbatim into local policy files only after verifying artifact bytes and decoded code hashes.","determinism_16_T":{"B":{"start":100000,"n":16,"mismatches":[],"scalar":{"total_edge":{"official":52.837927217806254,"per_seed":52.837927217806254},"retail_edge":{"official":65.11920644265,"per_seed":65.11920644265},"arb_edge":{"official":-12.2812792248875,"per_seed":-12.2812792248875}},"all_exact":true},"A":{"start":100000,"n":16,"mismatches":[],"scalar":{"total_edge":{"official":53.18343106676875,"per_seed":53.18343106676875},"retail_edge":{"official":63.893962342125,"per_seed":63.893962342125},"arb_edge":{"official":-10.71053127531875,"per_seed":-10.71053127531875}},"all_exact":true}},"commands":["git clone https://github.com/danrobinson/prediction-market-challenge.git test/scratch/blind-reference/sim; git -C test/scratch/blind-reference/sim checkout b244530ee2a6247b5f930830eeca9dd950da0e7e","curl -fL --silent --show-error https://api.imdnotdead.fun/artifacts/ecbc9087b4f238fc1b5b0d52f55af073f676c038bfb6756172b1e51480ac1741 -o test/scratch/blind-reference/B.artifact","curl -fL --silent --show-error https://api.imdnotdead.fun/artifacts/5aa77c807417d8eb4743635be24fb9590f57e3e636dfb11050dd283e0a14ad6d -o test/scratch/blind-reference/A.artifact","sha256sum test/scratch/blind-reference/B.artifact test/scratch/blind-reference/A.artifact","python3 test/scratch/blind-reference/run_measure.py B T --n 2; python3 test/scratch/blind-reference/run_measure.py B T","python3 test/scratch/blind-reference/evaluator.py run --sim-root test/scratch/blind-reference/sim --strategy test/scratch/blind-reference/B.py --sha256 baef955ec10728839f7c3357016ec9eb0550e7ec689bbd5171b1cdd5c9e37273 --start 200000 --n 2000 --out test/scratch/blind-reference/B_H.jsonl","python3 test/scratch/blind-reference/evaluator.py run --sim-root test/scratch/blind-reference/sim --strategy test/scratch/blind-reference/A.py --sha256 bd69d74807d70fc0acd7b35765b602bd05813b920c2ad706b10160baff45de22 --start 100000 --n 2000 --out test/scratch/blind-reference/A_T.jsonl","python3 test/scratch/blind-reference/evaluator.py run --sim-root test/scratch/blind-reference/sim --strategy test/scratch/blind-reference/A.py --sha256 bd69d74807d70fc0acd7b35765b602bd05813b920c2ad706b10160baff45de22 --start 200000 --n 2000 --out test/scratch/blind-reference/A_H.jsonl","python3 test/scratch/blind-reference/evaluator.py repeat --sim-root test/scratch/blind-reference/sim --strategy test/scratch/blind-reference/B.py --sha256 baef955ec10728839f7c3357016ec9eb0550e7ec689bbd5171b1cdd5c9e37273 --start 100000 --n 16 --records test/scratch/blind-reference/B_T.jsonl","python3 test/scratch/blind-reference/evaluator.py repeat --sim-root test/scratch/blind-reference/sim --strategy test/scratch/blind-reference/A.py --sha256 bd69d74807d70fc0acd7b35765b602bd05813b920c2ad706b10160baff45de22 --start 100000 --n 16 --records test/scratch/blind-reference/A_T.jsonl"],"completed":{"B":{"T":2000,"H":2000},"A":{"T":2000,"H":2000}},"failure_counts":{"B":{"T":0,"H":0},"A":{"T":0,"H":0}}}}