"""Complete exclusive block assignments with the measured electron mass fixed.""" from itertools import permutations from pathlib import Path import hashlib import json import math BUNDLE = Path(__file__).resolve().parent INPUT_FILE = BUNDLE / 'sector-inputs.json' INPUT = json.loads(INPUT_FILE.read_text()) MASS = INPUT['benchmark_mev'] assert MASS['electron'] == 0.51099895000 DEPTHS = (2, 3, 4, 6, 10) BLOCKS = ('bosons', 'down_quarks', 'up_quarks', 'electron_muon', 'tau') MEMBERS = (('W', 'Z', 'H'), ('down', 'strange', 'bottom'), ('up', 'charm', 'top'), ('muon',), ('tau',)) NAMES = tuple(name for members in MEMBERS for name in members) COEFFICIENT = {int(k): v for k, v in INPUT['coefficients'].items()} REFERENCE = {int(k): v for k, v in INPUT['reference_counts'].items()} FACTOR = {d: math.sqrt(COEFFICIENT[d] / COEFFICIENT[6]) / REFERENCE[d] for d in DEPTHS} N_MAX = 100 COUNTS = {d: [math.comb(n + d - 1, d) for n in range(1, N_MAX + 1)] for d in DEPTHS} CENTERS = {d: [math.log(FACTOR[d] * count) for count in COUNTS[d]] for d in DEPTHS} PERMUTATIONS = list(permutations(DEPTHS)) MAINTAINED = (2, 3, 4, 6, 10) MAINTAINED_ID = PERMUTATIONS.index(MAINTAINED) CHECKS = [] def check(name, condition): CHECKS.append({'name': name, 'passed': bool(condition)}) if not condition: raise AssertionError(name) def covered_fraction(centers, error, upper): total = 0.0 last_low = last_high = None for center in centers: low, high = max(0.0, center - error), min(upper, center + error) if low >= high: continue if last_high is not None and low <= last_high: last_high = max(high, last_high) else: if last_high is not None: total += last_high - last_low last_low, last_high = low, high if last_high is not None: total += last_high - last_low return total / upper def gamma_tail(x, shape=11): term = 1.0 values = [term] for j in range(1, shape): term *= x / j values.append(term) return math.exp(-x) * math.fsum(values) def make_row(name, d, anchor, upper): centers = [c - anchor for c in CENTERS[d]] observed = math.log(MASS[name] / MASS['electron']) index = min(range(N_MAX), key=lambda j: abs(centers[j] - observed)) error = abs(centers[index] - observed) probability = covered_fraction(centers, error, upper) assert 0 < probability <= 1.0 + 1e-13 probability = min(1.0, probability) return { 'particle': name, 'depth': d, 'index': index + 1, 'observed_mev': MASS[name], 'predicted_mev': MASS['electron'] * math.exp(centers[index]), 'signed_relative_residual': math.expm1(centers[index] - observed), 'log_error': error, 'probability': probability, } def details(candidate, upper): pid, ne, x, rms = candidate depths = PERMUTATIONS[pid] anchor = CENTERS[depths[3]][ne - 1] rows = [make_row(name, d, anchor, upper) for members, d in zip(MEMBERS, depths) for name in members] electron_factor = FACTOR[depths[3]] * COUNTS[depths[3]][ne - 1] check(f'details-{upper}-{pid}-{ne}:fixed-electron', math.isclose((MASS['electron'] / electron_factor) * electron_factor, MASS['electron'], rel_tol=2e-15)) return { 'permutation_id': pid, 'block_depths': dict(zip(BLOCKS, depths)), 'electron_index': ne, 'electron_observed_mev': MASS['electron'], 'electron_predicted_mev': MASS['electron'], 'electron_relative_residual': 0.0, 'common_normalization_relative_to_original': math.exp(-anchor), 'preserves_original_absolute_units': abs(anchor) <= 1e-14, 'preserves_shared_lepton_unit': FACTOR[depths[3]] == FACTOR[depths[4]], 'negative_log_product': x, 'fixed_candidate_tail': gamma_tail(x), 'rms_log_error': rms, 'rows': rows, 'repeated_indices_in_observed_triples': { block: len({row['index'] for row in rows if row['particle'] in members}) != len(members) for block, members in zip(BLOCKS[:3], MEMBERS[:3]) }, } def run_window(power): upper = math.log(10 ** power) baseline_rows = [make_row(name, d, 0.0, upper) for members, d in zip(MEMBERS, MAINTAINED) for name in members] baseline = {row['particle']: row['log_error'] for row in baseline_rows} records = [] original_units = [] shared_leptons = [] both_gates = [] no_worse_alternate = [] grid_x = [[None] * N_MAX for _ in PERMUTATIONS] grid_rms = [[None] * N_MAX for _ in PERMUTATIONS] for electron_depth in DEPTHS: legal_ids = [pid for pid, ds in enumerate(PERMUTATIONS) if ds[3] == electron_depth] check(f'window{power}:d{electron_depth}:exclusive-permutation-count', len(legal_ids) == 24) for ne in range(1, N_MAX + 1): anchor = CENTERS[electron_depth][ne - 1] table = {} for name in NAMES: allowed = [electron_depth] if name == 'muon' else [d for d in DEPTHS if d != electron_depth] for d in allowed: table[name, d] = make_row(name, d, anchor, upper) for pid in legal_ids: ds = PERMUTATIONS[pid] rows = [table[name, d] for members, d in zip(MEMBERS, ds) for name in members] x = -math.fsum(math.log(row['probability']) for row in rows) rms = math.sqrt(math.fsum(row['log_error'] ** 2 for row in rows) / 11) candidate = (pid, ne, x, rms) records.append(candidate) grid_x[pid][ne - 1] = x grid_rms[pid][ne - 1] = rms same_units = abs(anchor) <= 1e-14 same_lepton_scale = FACTOR[ds[3]] == FACTOR[ds[4]] if same_units: original_units.append(candidate) if same_lepton_scale: shared_leptons.append(candidate) if same_units and same_lepton_scale: both_gates.append(candidate) if pid != MAINTAINED_ID and all(row['log_error'] <= baseline[row['particle']] + 1e-14 for row in rows): no_worse_alternate.append(candidate) check(f'window{power}:all-candidates', len(records) == 12000 and all(value is not None for row in grid_x for value in row)) check(f'window{power}:shared-lepton-candidates', len(shared_leptons) == 1200) summaries = [] for label, group in [('all_common_normalizations', records), ('shared_lepton_unit', shared_leptons), ('original_absolute_units', original_units), ('both_preserved', both_gates)]: ordered = sorted(group, key=lambda row: row[2], reverse=True) raw = sorted(group, key=lambda row: row[3]) best, raw_best = ordered[0], raw[0] best_other = next(row for row in ordered if row[0] != MAINTAINED_ID) raw_other = next(row for row in raw if row[0] != MAINTAINED_ID) q = gamma_tail(best[2]) summaries.append({ 'class': label, 'complete_candidate_count': len(group), 'distinct_permutation_count': len({row[0] for row in group}), 'best_calibrated': details(best, upper), 'best_raw': details(raw_best, upper), 'best_alternate_permutation_calibrated': details(best_other, upper), 'best_alternate_permutation_raw': details(raw_other, upper), 'calibrated_winner_ties_1e12': sum(abs(row[2] - best[2]) <= 1e-12 for row in group), 'raw_winner_ties_1e12': sum(abs(row[3] - raw_best[3]) <= 1e-12 for row in group), 'searched_tail_lower_bound': q, 'searched_tail_upper_bound': min(1.0, len(group) * q), }) maintained = next(row for row in records if row[:2] == (MAINTAINED_ID, 13)) old = next(w for w in INPUT['finite_reference_checks'] if w['ratio_window'][1] == 10 ** power) check(f'window{power}:maintained-tail-reproduced', math.isclose(gamma_tail(maintained[2]), old['searched_tail_lower_bound'], rel_tol=2e-12)) check(f'window{power}:maintained-raw-reproduced', math.isclose(maintained[3], old['best_assignment']['rms_log_residual'], rel_tol=2e-12)) return { 'ratio_window': [1, 10 ** power], 'maintained': details(maintained, upper), 'classes': summaries, 'no_worse_alternate_permutations': [details(row, upper) for row in no_worse_alternate], 'score_grid': grid_x, 'rms_grid': grid_rms, 'best_permutation_summaries': [{ 'permutation_id': pid, 'block_depths': dict(zip(BLOCKS, ds)), 'best_electron_index_calibrated': max(range(N_MAX), key=lambda j: grid_x[pid][j]) + 1, 'best_electron_index_raw': min(range(N_MAX), key=lambda j: grid_rms[pid][j]) + 1, 'max_score': max(grid_x[pid]), 'min_rms': min(grid_rms[pid]), } for pid, ds in enumerate(PERMUTATIONS)], } check('permutations-exclusive-and-complete', len(PERMUTATIONS) == len(set(PERMUTATIONS)) == 120 and all(len(set(ds)) == 5 for ds in PERMUTATIONS)) check('maintained-electron-normalization', CENTERS[6][12] == 0.0) check('overlap-boundary-union', abs(covered_fraction([0.4, 0.48, 1.2, 1.98], 0.1, 2) - 0.3) < 1e-14) check('outside-centers', abs(covered_fraction([-0.05, 1.05], 0.1, 1) - 0.1) < 1e-14) windows = [run_window(power) for power in (6, 7)] report = { 'status': 'passed', 'sources': {p.name: hashlib.sha256(p.read_bytes()).hexdigest() for p in (Path(__file__), INPUT_FILE)}, 'benchmark_mev': MASS, 'dimensionless_sector_factors': FACTOR, 'depth_domain': DEPTHS, 'index_range': [1, N_MAX], 'block_order': BLOCKS, 'permutations': PERMUTATIONS, 'maintained_permutation_id': MAINTAINED_ID, 'reference_mass_is_fixed': True, 'electron_is_conditioned_not_an_independent_prediction': True, 'normalization': 'One common value determined by the same fixed measured electron for each trial depth and index; relative sector factors fixed.', 'windows': windows, 'checks': CHECKS, 'scope': 'Finite mass-pattern search with exclusive sectors. Bounds condition on fixed relative numerical recipe; not historical discovery significance or a physical model derivation.', } (BUNDLE / 'finite-sector-results.json').write_text(json.dumps(report, indent=2) + '\n') print(json.dumps({'status': 'passed', 'checks': len(CHECKS), 'primary': [{'class': c['class'], 'count': c['complete_candidate_count'], 'best_calibrated': [c['best_calibrated']['block_depths'], c['best_calibrated']['electron_index']], 'best_raw': [c['best_raw']['block_depths'], c['best_raw']['electron_index']], 'upper_bound': c['searched_tail_upper_bound'], 'best_other_raw': [c['best_alternate_permutation_raw']['block_depths'], c['best_alternate_permutation_raw']['electron_index'], c['best_alternate_permutation_raw']['rms_log_error']]} for c in windows[0]['classes']], 'no_worse_alternate_count': len(windows[0]['no_worse_alternate_permutations'])},indent=2))