#!/usr/bin/env python3 """ ANALYSIS 2E: SCALE RATIO MYSTERY ================================= The ratio a_known / lambda_C (lattice constant / Compton wavelength) varies ~400x across elements. Standard physics explains lattice constants through atomic radii (Bohr model). TLT should connect Compton wavelength to lattice constant. We compute lambda_C = h/(m*c), then ratio = a / lambda_C, and look for patterns by atomic number, structure type, period, and derived atomic radius. """ import sys import math from pathlib import Path from collections import defaultdict sys.path.insert(0, str(Path(__file__).parent.parent)) from full_element_database import build_elements_dict # Constants c = 299792458.0 # m/s h = 6.62607015e-34 # J·s amu_kg = 1.66053906660e-27 # kg per amu ARCHETYPES = {"FCC", "BCC", "HCP", "Diamond"} # Electron block assignment by Z def electron_block(Z): """Return s/p/d/f block for element with atomic number Z.""" # s-block: groups 1-2 + He s_block = {1, 2, 3, 4, 11, 12, 19, 20, 37, 38, 55, 56, 87, 88} # f-block: lanthanides 57-71, actinides 89-103 f_block = set(range(57, 72)) | set(range(89, 104)) # d-block: 21-30, 39-48, 72-80, 104-112 d_block = set(range(21, 31)) | set(range(39, 49)) | set(range(72, 81)) | set(range(104, 113)) # Everything else is p-block if Z in s_block: return "s" elif Z in f_block: return "f" elif Z in d_block: return "d" else: return "p" def compute_atomic_radius(a_angstrom, structure): """Estimate metallic/covalent atomic radius from lattice constant and structure.""" a = a_angstrom # in angstroms if structure == "FCC": # FCC: a = 2*sqrt(2)*r -> r = a / (2*sqrt(2)) return a / (2 * math.sqrt(2)) elif structure == "BCC": # BCC: a = 4r / sqrt(3) -> r = a*sqrt(3)/4 return a * math.sqrt(3) / 4 elif structure == "HCP": # HCP: a = 2r -> r = a/2 return a / 2 elif structure == "Diamond": # Diamond: a = 8r / sqrt(3) -> r = a*sqrt(3)/8 return a * math.sqrt(3) / 8 else: return a / 2 # rough default def main(): elements = build_elements_dict() # Filter: known lattice constant > 0, cipher-covered structure candidates = [] for sym, data in sorted(elements.items(), key=lambda x: x[1]["Z"]): struct = data["crystal_structure"] a = data["lattice_a_angstrom"] if a > 0 and struct in ARCHETYPES: mass_kg = data["mass_amu"] * amu_kg lambda_C = h / (mass_kg * c) # Compton wavelength in meters a_m = a * 1e-10 # lattice constant in meters ratio = a_m / lambda_C r_atomic = compute_atomic_radius(a, struct) block = electron_block(data["Z"]) candidates.append({ "sym": sym, "name": data["name"], "Z": data["Z"], "period": data["period"], "struct": struct, "mass_amu": data["mass_amu"], "a_angstrom": a, "lambda_C_m": lambda_C, "lambda_C_fm": lambda_C * 1e15, # femtometers "ratio": ratio, "ratio_over_Z": ratio / data["Z"], "r_atomic_A": r_atomic, "block": block, "conductor": data["conductor"], }) # ==================================================================== # BUILD THE REPORT # ==================================================================== lines = [] lines.append("=" * 90) lines.append("ANALYSIS 2E: SCALE RATIO MYSTERY — a_lattice / lambda_Compton") lines.append("=" * 90) lines.append(f"Date: 2026-03-17") lines.append(f"Elements analyzed: {len(candidates)} (with a > 0 and structure in FCC/BCC/HCP/Diamond)") lines.append(f"") lines.append(f"lambda_C = h / (m * c) where m = mass_amu * {amu_kg:.15e} kg") lines.append(f"ratio = a_lattice [m] / lambda_C [m]") lines.append(f"") # ---- FULL TABLE ---- lines.append("-" * 90) lines.append("FULL DATA TABLE") lines.append("-" * 90) header = f"{'Sym':>4s} {'Z':>3s} {'Per':>3s} {'Struct':>7s} {'Block':>5s} {'a(A)':>7s} {'lambda_C(fm)':>12s} {'ratio':>12s} {'ratio/Z':>10s} {'r_atom(A)':>9s}" lines.append(header) lines.append("-" * len(header)) for c_data in candidates: lines.append( f"{c_data['sym']:>4s} {c_data['Z']:>3d} {c_data['period']:>3d} " f"{c_data['struct']:>7s} {c_data['block']:>5s} " f"{c_data['a_angstrom']:>7.3f} {c_data['lambda_C_fm']:>12.4f} " f"{c_data['ratio']:>12.1f} {c_data['ratio_over_Z']:>10.2f} " f"{c_data['r_atomic_A']:>9.3f}" ) # ---- STATISTICS ---- all_ratios = [c_data["ratio"] for c_data in candidates] lines.append(f"\n{'='*90}") lines.append(f"GLOBAL STATISTICS") lines.append(f"{'='*90}") lines.append(f" Min ratio: {min(all_ratios):>12.1f} ({[c for c in candidates if c['ratio']==min(all_ratios)][0]['sym']})") lines.append(f" Max ratio: {max(all_ratios):>12.1f} ({[c for c in candidates if c['ratio']==max(all_ratios)][0]['sym']})") lines.append(f" Spread: {max(all_ratios)/min(all_ratios):>12.1f}x") lines.append(f" Mean ratio: {sum(all_ratios)/len(all_ratios):>12.1f}") lines.append(f" Median: {sorted(all_ratios)[len(all_ratios)//2]:>12.1f}") # ---- RATIO vs Z: IS THERE A TREND? ---- lines.append(f"\n{'='*90}") lines.append(f"PATTERN 1: RATIO vs ATOMIC NUMBER (Z)") lines.append(f"{'='*90}") lines.append(f"If ratio ~ Z, then lattice constant scales linearly with Compton wavelength * Z.") lines.append(f"If ratio ~ Z^2, it follows Bohr-model scaling (atomic radius ~ 1/Z for inner shells).") lines.append(f"") # Compute correlation n = len(candidates) sum_z = sum(c_data["Z"] for c_data in candidates) sum_r = sum(c_data["ratio"] for c_data in candidates) sum_zr = sum(c_data["Z"] * c_data["ratio"] for c_data in candidates) sum_z2 = sum(c_data["Z"]**2 for c_data in candidates) sum_r2 = sum(c_data["ratio"]**2 for c_data in candidates) denom = math.sqrt((n * sum_z2 - sum_z**2) * (n * sum_r2 - sum_r**2)) if denom > 0: corr_z = (n * sum_zr - sum_z * sum_r) / denom else: corr_z = 0 lines.append(f" Pearson correlation (ratio vs Z): r = {corr_z:.4f}") # Also check ratio vs Z^2 sum_z2_val = sum(c_data["Z"]**2 for c_data in candidates) sum_z2r = sum(c_data["Z"]**2 * c_data["ratio"] for c_data in candidates) sum_z4 = sum(c_data["Z"]**4 for c_data in candidates) denom2 = math.sqrt((n * sum_z4 - sum_z2_val**2) * (n * sum_r2 - sum_r**2)) if denom2 > 0: corr_z2 = (n * sum_z2r - sum_z2_val * sum_r) / denom2 else: corr_z2 = 0 lines.append(f" Pearson correlation (ratio vs Z^2): r = {corr_z2:.4f}") # Check log(ratio) vs log(Z) to find power law log_z = [math.log(c_data["Z"]) for c_data in candidates] log_r = [math.log(c_data["ratio"]) for c_data in candidates] n_log = len(log_z) s_lz = sum(log_z) s_lr = sum(log_r) s_lzlr = sum(a * b for a, b in zip(log_z, log_r)) s_lz2 = sum(a**2 for a in log_z) s_lr2 = sum(a**2 for a in log_r) denom_log = math.sqrt((n_log * s_lz2 - s_lz**2) * (n_log * s_lr2 - s_lr**2)) if denom_log > 0: corr_log = (n_log * s_lzlr - s_lz * s_lr) / denom_log else: corr_log = 0 # Power law slope: log(ratio) = alpha * log(Z) + beta if (n_log * s_lz2 - s_lz**2) != 0: alpha = (n_log * s_lzlr - s_lz * s_lr) / (n_log * s_lz2 - s_lz**2) beta = (s_lr - alpha * s_lz) / n_log else: alpha, beta = 0, 0 lines.append(f" Power law fit: ratio ~ Z^{alpha:.3f} (r = {corr_log:.4f})") lines.append(f" Prefactor: e^beta = {math.exp(beta):.1f}") lines.append(f"") if alpha > 1.5: lines.append(f" FINDING: ratio grows FASTER than Z (alpha > 1.5), meaning heavier") lines.append(f" elements have disproportionately larger a/lambda_C.") elif alpha > 0.8: lines.append(f" FINDING: ratio grows approximately linearly with Z (alpha ~ 1),") lines.append(f" meaning a/lambda_C ~ Z. This implies a ~ Z * lambda_C = Z*h/(mc).") else: lines.append(f" FINDING: ratio grows SUB-linearly with Z (alpha < 0.8).") # ---- ratio / Z analysis ---- lines.append(f"\n{'='*90}") lines.append(f"PATTERN 2: RATIO / Z — DOES THIS NORMALIZE?") lines.append(f"{'='*90}") roz_vals = [c_data["ratio_over_Z"] for c_data in candidates] lines.append(f" If ratio/Z is approximately constant, then a_lattice ~ Z * lambda_C.") lines.append(f" Min ratio/Z: {min(roz_vals):>10.2f} ({[c for c in candidates if c['ratio_over_Z']==min(roz_vals)][0]['sym']})") lines.append(f" Max ratio/Z: {max(roz_vals):>10.2f} ({[c for c in candidates if c['ratio_over_Z']==max(roz_vals)][0]['sym']})") lines.append(f" Spread: {max(roz_vals)/min(roz_vals):>10.1f}x") lines.append(f" Mean: {sum(roz_vals)/len(roz_vals):>10.2f}") lines.append(f" Std dev: {math.sqrt(sum((v - sum(roz_vals)/len(roz_vals))**2 for v in roz_vals) / len(roz_vals)):>10.2f}") lines.append(f" Coeff of var: {math.sqrt(sum((v - sum(roz_vals)/len(roz_vals))**2 for v in roz_vals) / len(roz_vals)) / (sum(roz_vals)/len(roz_vals)) * 100:>10.1f}%") if max(roz_vals) / min(roz_vals) < 5: lines.append(f"\n FINDING: ratio/Z has much less spread ({max(roz_vals)/min(roz_vals):.1f}x vs {max(all_ratios)/min(all_ratios):.0f}x for raw ratio).") lines.append(f" Dividing by Z partially normalizes the ratio, suggesting a ~ Z * lambda_C.") else: lines.append(f"\n FINDING: ratio/Z still varies {max(roz_vals)/min(roz_vals):.1f}x. Z alone does not normalize.") # ---- RATIO BY STRUCTURE TYPE ---- lines.append(f"\n{'='*90}") lines.append(f"PATTERN 3: RATIO CONSTANCY WITHIN EACH STRUCTURE TYPE") lines.append(f"{'='*90}") lines.append(f"If the cipher's geometry fully determines the scale relationship, then") lines.append(f"ratio should be constant (or at least tighter) within each archetype.") lines.append(f"") for struct in ["FCC", "BCC", "HCP", "Diamond"]: group = [c_data for c_data in candidates if c_data["struct"] == struct] if not group: continue ratios = [c_data["ratio"] for c_data in group] roz = [c_data["ratio_over_Z"] for c_data in group] mean_r = sum(ratios) / len(ratios) std_r = math.sqrt(sum((v - mean_r)**2 for v in ratios) / len(ratios)) cv_r = std_r / mean_r * 100 if mean_r > 0 else 0 mean_roz = sum(roz) / len(roz) std_roz = math.sqrt(sum((v - mean_roz)**2 for v in roz) / len(roz)) cv_roz = std_roz / mean_roz * 100 if mean_roz > 0 else 0 lines.append(f" {struct} ({len(group)} elements):") lines.append(f" ratio: min={min(ratios):>10.1f} max={max(ratios):>10.1f} " f"mean={mean_r:>10.1f} CV={cv_r:>5.1f}% spread={max(ratios)/min(ratios):>5.1f}x") lines.append(f" ratio/Z: min={min(roz):>10.2f} max={max(roz):>10.2f} " f"mean={mean_roz:>10.2f} CV={cv_roz:>5.1f}% spread={max(roz)/min(roz):>5.1f}x") # List the elements sorted by ratio group_sorted = sorted(group, key=lambda x: x["ratio"]) lines.append(f" Elements (sorted by ratio):") for g in group_sorted: lines.append(f" {g['sym']:>4s} (Z={g['Z']:>3d}, Per={g['period']}): " f"ratio={g['ratio']:>10.1f} ratio/Z={g['ratio_over_Z']:>8.2f} " f"a={g['a_angstrom']:.3f}A lambda_C={g['lambda_C_fm']:.3f}fm") lines.append(f"") # ---- RATIO BY PERIOD ---- lines.append(f"\n{'='*90}") lines.append(f"PATTERN 4: RATIO vs PERIOD NUMBER") lines.append(f"{'='*90}") lines.append(f"Standard physics: atomic radius follows periodic trends (grows with period,") lines.append(f"shrinks across a period due to nuclear charge). Does ratio track period?") lines.append(f"") by_period = defaultdict(list) for c_data in candidates: by_period[c_data["period"]].append(c_data) for period in sorted(by_period.keys()): group = by_period[period] ratios = [c_data["ratio"] for c_data in group] mean_r = sum(ratios) / len(ratios) lines.append(f" Period {period} ({len(group)} elements):") lines.append(f" ratio range: {min(ratios):.1f} - {max(ratios):.1f}, mean={mean_r:.1f}") for g in sorted(group, key=lambda x: x["Z"]): lines.append(f" {g['sym']:>4s} (Z={g['Z']:>3d}, {g['struct']:>7s}): ratio={g['ratio']:>10.1f}") lines.append(f"") # Check correlation with period sum_p = sum(c_data["period"] for c_data in candidates) sum_pr = sum(c_data["period"] * c_data["ratio"] for c_data in candidates) sum_p2 = sum(c_data["period"]**2 for c_data in candidates) denom_p = math.sqrt((n * sum_p2 - sum_p**2) * (n * sum_r2 - sum_r**2)) if denom_p > 0: corr_p = (n * sum_pr - sum_p * sum_r) / denom_p else: corr_p = 0 lines.append(f" Pearson correlation (ratio vs period): r = {corr_p:.4f}") # ---- RATIO vs ATOMIC RADIUS ---- lines.append(f"\n{'='*90}") lines.append(f"PATTERN 5: RATIO vs DERIVED ATOMIC RADIUS") lines.append(f"{'='*90}") lines.append(f"If ratio simply reflects atomic size, ratio should correlate tightly with r_atomic.") lines.append(f"Atomic radius derived from structure: FCC r=a/(2*sqrt(2)), BCC r=a*sqrt(3)/4, etc.") lines.append(f"") radii = [c_data["r_atomic_A"] for c_data in candidates] sum_rad = sum(radii) sum_rad_r = sum(r * c_data["ratio"] for r, c_data in zip(radii, candidates)) sum_rad2 = sum(r**2 for r in radii) denom_rad = math.sqrt((n * sum_rad2 - sum_rad**2) * (n * sum_r2 - sum_r**2)) if denom_rad > 0: corr_rad = (n * sum_rad_r - sum_rad * sum_r) / denom_rad else: corr_rad = 0 lines.append(f" Pearson correlation (ratio vs r_atomic): r = {corr_rad:.4f}") lines.append(f"") # ratio / r_atomic: does this normalize? ratio_over_r = [c_data["ratio"] / c_data["r_atomic_A"] for c_data in candidates] mean_ror = sum(ratio_over_r) / len(ratio_over_r) std_ror = math.sqrt(sum((v - mean_ror)**2 for v in ratio_over_r) / len(ratio_over_r)) lines.append(f" ratio / r_atomic:") lines.append(f" min = {min(ratio_over_r):.1f} max = {max(ratio_over_r):.1f} spread = {max(ratio_over_r)/min(ratio_over_r):.1f}x") lines.append(f" mean = {mean_ror:.1f} CV = {std_ror/mean_ror*100:.1f}%") # ---- DIMENSIONAL ANALYSIS: WHAT DOES ratio PHYSICALLY MEAN? ---- lines.append(f"\n{'='*90}") lines.append(f"PATTERN 6: DIMENSIONAL/PHYSICAL INTERPRETATION") lines.append(f"{'='*90}") lines.append(f""" The Compton wavelength is: lambda_C = h / (m * c) The lattice constant a is set by: a ~ 2 * r_atomic (roughly, depending on structure) The ratio is: ratio = a / lambda_C = a * m * c / h Since a ~ r_atomic and r_atomic ~ a_0 * n^2 / Z_eff (Bohr model): ratio ~ (a_0 * n^2 / Z_eff) * (Z * m_p * c / h) = (a_0 * c * m_p / h) * Z * n^2 / Z_eff The quantity a_0 * m_p * c / h: a_0 = 5.29177e-11 m m_p = 1.67262e-27 kg a_0 * m_p * c / h = 5.29177e-11 * 1.67262e-27 * 299792458 / 6.62607e-34""") a_0 = 5.29177e-11 m_p = 1.67262e-27 universal = a_0 * m_p * c / h lines.append(f" = {universal:.4f}") lines.append(f"") lines.append(f" So ratio ~ {universal:.1f} * Z * n^2 / Z_eff") lines.append(f" This is purely standard physics: the ratio contains NO new information") lines.append(f" beyond the Bohr model's prediction of atomic radii.") lines.append(f"") lines.append(f" FOR TLT: The question is whether there exists a DIFFERENT formula") lines.append(f" connecting a_lattice to lambda_C that depends on the STRUCTURE TYPE") lines.append(f" (coordination number, packing geometry) rather than Z_eff.") # ---- Check: ratio / (Z * mass_amu) — would cancel if ratio ~ m^2 ---- lines.append(f"\n{'='*90}") lines.append(f"PATTERN 7: SEARCHING FOR A STRUCTURE-DEPENDENT CONSTANT") lines.append(f"{'='*90}") # Try: ratio / Z^alpha for best alpha per structure type for struct in ["FCC", "BCC", "HCP", "Diamond"]: group = [c_data for c_data in candidates if c_data["struct"] == struct] if len(group) < 3: continue lines.append(f"\n {struct}: fitting ratio = k * Z^alpha") # Find alpha that minimizes coefficient of variation best_alpha = 0 best_cv = 1e10 for a_try in [x * 0.05 for x in range(1, 60)]: normalized = [c_data["ratio"] / (c_data["Z"] ** a_try) for c_data in group] mean_n = sum(normalized) / len(normalized) std_n = math.sqrt(sum((v - mean_n)**2 for v in normalized) / len(normalized)) cv_n = std_n / mean_n * 100 if mean_n > 0 else 1e10 if cv_n < best_cv: best_cv = cv_n best_alpha = a_try # Refine for a_try in [best_alpha + x * 0.005 for x in range(-10, 11)]: if a_try <= 0: continue normalized = [c_data["ratio"] / (c_data["Z"] ** a_try) for c_data in group] mean_n = sum(normalized) / len(normalized) std_n = math.sqrt(sum((v - mean_n)**2 for v in normalized) / len(normalized)) cv_n = std_n / mean_n * 100 if mean_n > 0 else 1e10 if cv_n < best_cv: best_cv = cv_n best_alpha = a_try normalized = [c_data["ratio"] / (c_data["Z"] ** best_alpha) for c_data in group] mean_k = sum(normalized) / len(normalized) lines.append(f" Best alpha = {best_alpha:.3f}, k = {mean_k:.2f}, CV = {best_cv:.1f}%") lines.append(f" (If alpha ~ 2, this is Bohr-model scaling: r ~ n^2/Z, but mass ~ Z so ratio ~ Z)") lines.append(f" Normalized values:") for c_data in sorted(group, key=lambda x: x["Z"]): nv = c_data["ratio"] / (c_data["Z"] ** best_alpha) lines.append(f" {c_data['sym']:>4s} Z={c_data['Z']:>3d}: ratio/Z^{best_alpha:.2f} = {nv:.2f}") # ---- CONDUCTOR vs INSULATOR within same structure ---- lines.append(f"\n{'='*90}") lines.append(f"PATTERN 8: CONDUCTORS vs NON-CONDUCTORS WITHIN SAME STRUCTURE") lines.append(f"{'='*90}") lines.append(f"Noble gases and molecular solids with FCC/HCP structures are insulators.") lines.append(f"Does their ratio differ systematically from metallic FCC/HCP?") lines.append(f"") for struct in ["FCC", "HCP"]: group = [c_data for c_data in candidates if c_data["struct"] == struct] metals = [c_data for c_data in group if c_data["conductor"]] nonmetals = [c_data for c_data in group if not c_data["conductor"]] if metals and nonmetals: m_ratios = [c_data["ratio"] for c_data in metals] nm_ratios = [c_data["ratio"] for c_data in nonmetals] m_roz = [c_data["ratio_over_Z"] for c_data in metals] nm_roz = [c_data["ratio_over_Z"] for c_data in nonmetals] lines.append(f" {struct}:") lines.append(f" Metals ({len(metals)}): ratio range {min(m_ratios):.0f}-{max(m_ratios):.0f}, " f"ratio/Z range {min(m_roz):.2f}-{max(m_roz):.2f}, mean ratio/Z = {sum(m_roz)/len(m_roz):.2f}") lines.append(f" Non-metals ({len(nonmetals)}): ratio range {min(nm_ratios):.0f}-{max(nm_ratios):.0f}, " f"ratio/Z range {min(nm_roz):.2f}-{max(nm_roz):.2f}, mean ratio/Z = {sum(nm_roz)/len(nm_roz):.2f}") lines.append(f" Non-metal elements: {', '.join(c['sym'] for c in nonmetals)}") lines.append(f"") # ---- KEY CONCLUSIONS ---- lines.append(f"\n{'='*90}") lines.append(f"CONCLUSIONS") lines.append(f"{'='*90}") lines.append(f""" 1. RAW RATIO SCALES WITH Z: The ratio a/lambda_C ranges from ~{min(all_ratios):.0f} to ~{max(all_ratios):.0f} ({max(all_ratios)/min(all_ratios):.0f}x spread). It correlates strongly with Z (r = {corr_z:.3f}) and follows a power law ratio ~ Z^{alpha:.2f}. 2. ratio/Z PARTIALLY NORMALIZES: Dividing by Z reduces spread from {max(all_ratios)/min(all_ratios):.0f}x to {max(roz_vals)/min(roz_vals):.1f}x. This is expected: in standard physics, a ~ r_atomic (which depends on principal quantum number and effective charge) while lambda_C ~ 1/m ~ 1/(Z*m_p), so ratio ~ r_atomic * Z * m_p * c / h. 3. STRUCTURE TYPE DOES NOT MAKE RATIO CONSTANT: Within each structure type, the ratio still varies enormously (spread within FCC alone is large). The cipher's geometry does NOT determine a unique scale relationship. 4. THE BOHR MODEL DOMINATES: The dimensional analysis shows ratio ~ {universal:.1f} * Z * n^2 / Z_eff, which is entirely standard physics. The ratio contains atomic radius information (set by quantum mechanics of electron shells), not lattice geometry information. 5. TLT IMPLICATION: For TLT to add value here, it would need to provide a DIFFERENT formula for atomic radius that depends on: - Compton wavelength (lambda_C = h/mc) - Coordination number (4, 8, or 12) - Some TLT-specific quantity (e.g., a ledger phase angle, {2,3} packing fraction) that reproduces the ~{len(candidates)} known lattice constants WITHOUT invoking the Bohr model's Z_eff and principal quantum number. 6. MOST PROMISING DIRECTION: Within each structure type, the ratio/Z^alpha fit yields structure-dependent constants. If these constants map to cipher values (e.g., related to coordination number or packing fraction), that would be a genuine TLT prediction. 7. CONDUCTOR vs INSULATOR: Noble gases with FCC/HCP structures have systematically DIFFERENT ratio/Z values than metals with the same structure. This suggests the cipher needs a second variable beyond geometry to explain the metal/insulator distinction (as noted in R1 of the cipher validation). """) lines.append("=" * 90) lines.append("DATA SHOWS WHAT IT SHOWS.") lines.append("=" * 90) report = "\n".join(lines) # Write output output_path = Path(__file__).parent / "scale_ratio_analysis.txt" with open(output_path, "w") as f: f.write(report) print(f"Wrote: {output_path}") print(f"Elements analyzed: {len(candidates)}") print(report[:2000]) # preview if __name__ == "__main__": main()