#!/usr/bin/env python3
"""
clean_numbers_only_script.py

Mathematical verification showing only calculated results.
NO conclusions, NO claims - just numbers.

Author: Andre Heinecke & AI Collaborators
Date: June 2025
License: CC BY-SA 4.0
"""

import numpy as np
import sys

# Physical constants (CODATA 2018 values)
HBAR = 1.054571817e-34  # J*s (reduced Planck constant)
ME = 9.1093837015e-31   # kg (electron mass)
E = 1.602176634e-19     # C (elementary charge)
K = 8.9875517923e9      # N*m^2/C^2 (Coulomb constant)
A0 = 5.29177210903e-11  # m (Bohr radius)
ALPHA = 1/137.035999084 # Fine structure constant

def calculate_z_eff_slater(Z):
    """Calculate effective nuclear charge using Slater's rules (simplified)"""
    if Z == 1:
        return 1.0
    else:
        screening = 0.31 + 0.002 * (Z - 2) / 98
        return Z - screening

def relativistic_gamma(Z, n=1):
    """Calculate relativistic correction factor"""
    v_over_c = Z * ALPHA / n
    
    if v_over_c < 0.1:
        gamma = 1 + 0.5 * v_over_c**2
    else:
        gamma = 1 / np.sqrt(1 - v_over_c**2)
    
    if Z > 70:
        qed_correction = 1 + ALPHA**2 * (Z/137)**2 / 8
        gamma *= qed_correction
        
    return gamma

def calculate_forces(Z):
    """Calculate both forces for element Z"""
    Z_eff = calculate_z_eff_slater(Z)
    r = A0 / Z_eff
    gamma = relativistic_gamma(Z, n=1)
    
    # Calculate forces
    F_centripetal = HBAR**2 / (gamma * ME * r**3)
    F_coulomb = K * Z_eff * E**2 / (gamma * r**2)
    
    ratio = F_centripetal / F_coulomb
    deviation_ppb = abs(1 - ratio) * 1e9
    
    return {
        'Z': Z,
        'Z_eff': Z_eff,
        'r_m': r,
        'r_pm': r * 1e12,
        'gamma': gamma,
        'F_centripetal': F_centripetal,
        'F_coulomb': F_coulomb,
        'ratio': ratio,
        'deviation_ppb': deviation_ppb,
        'agreement_percent': ratio * 100
    }

def verify_bohr_radius():
    """Calculate Bohr radius from force balance"""
    print("Bohr radius calculation:")
    print("Force balance: hbar^2/(m*r^3) = k*e^2/r^2")
    print("Solving for r: r = hbar^2/(m*k*e^2)")
    
    a0_calculated = HBAR**2 / (ME * K * E**2)
    a0_defined = A0
    agreement = a0_calculated / a0_defined
    
    print(f"a0 calculated = {a0_calculated:.11e} m")
    print(f"a0 defined    = {a0_defined:.11e} m")
    print(f"ratio         = {agreement:.15f}")
    print()

def analyze_element(Z, element_name=""):
    """Show detailed analysis for one element"""
    result = calculate_forces(Z)
    
    print(f"{element_name} (Z = {Z}):")
    print(f"  Z_eff = {result['Z_eff']:.6f}")
    print(f"  radius = {result['r_pm']:.3f} pm = {result['r_m']:.6e} m")
    print(f"  gamma = {result['gamma']:.6f}")
    print(f"  F_centripetal = {result['F_centripetal']:.6e} N")
    print(f"  F_coulomb     = {result['F_coulomb']:.6e} N")
    print(f"  ratio = {result['ratio']:.15f}")
    print(f"  agreement = {result['agreement_percent']:.13f}%")
    print(f"  deviation = {result['deviation_ppb']:.3f} ppb")
    print()

def verify_all_elements():
    """Calculate forces for all elements and show statistics"""
    print("Verification across periodic table:")
    print("Formula: F = hbar^2/(gamma*m*r^3) vs F = k*e^2/r^2")
    print()
    
    element_names = [
        'H', 'He', 'Li', 'Be', 'B', 'C', 'N', 'O', 'F', 'Ne',
        'Na', 'Mg', 'Al', 'Si', 'P', 'S', 'Cl', 'Ar', 'K', 'Ca'
    ]
    
    print(f"{'Z':>3} {'Elem':>4} {'Z_eff':>8} {'gamma':>8} {'F_ratio':>15} {'Dev(ppb)':>12}")
    print("-" * 60)
    
    results = []
    for Z in range(1, 101):
        result = calculate_forces(Z)
        results.append(result)
        
        # Print selected elements
        if Z <= 20 or Z in [26, 47, 79, 92]:
            element = element_names[Z-1] if Z <= len(element_names) else f"Z{Z}"
            if Z == 26: element = "Fe"
            elif Z == 47: element = "Ag" 
            elif Z == 79: element = "Au"
            elif Z == 92: element = "U"
            
            print(f"{Z:3d} {element:>4} {result['Z_eff']:8.3f} {result['gamma']:8.4f} "
                  f"{result['ratio']:15.12f} {result['deviation_ppb']:12.3f}")
    
    print("-" * 60)
    print()
    
    # Calculate statistics (don't hardcode anything)
    ratios = [r['ratio'] for r in results]
    deviations = [r['deviation_ppb'] for r in results]
    agreements = [r['agreement_percent'] for r in results]
    
    print("Statistical results:")
    print(f"  Elements calculated: {len(results)}")
    print(f"  Mean ratio: {np.mean(ratios):.15f}")
    print(f"  Mean agreement: {np.mean(agreements):.11f}%")
    print(f"  Mean deviation: {np.mean(deviations):.6f} ppb")
    print(f"  Std deviation:  {np.std(deviations):.6f} ppb")
    print(f"  Min deviation:  {np.min(deviations):.6f} ppb")
    print(f"  Max deviation:  {np.max(deviations):.6f} ppb")
    print(f"  Range of deviations: {np.max(deviations) - np.min(deviations):.6f} ppb")
    
    # Calculate if deviations are similar (don't hardcode True/False)
    deviation_range = np.max(deviations) - np.min(deviations)
    print(f"  Deviation range < 1 ppb: {deviation_range < 1.0}")
    print(f"  All ratios > 0.999: {all(r > 0.999 for r in ratios)}")
    print(f"  All ratios < 1.001: {all(r < 1.001 for r in ratios)}")
    print()
    
    return results

def main():
    """Main calculation routine - numbers only"""
    print("Mathematical verification: F = hbar^2/(gamma*m*r^3) vs k*e^2/r^2")
    print("Repository: https://git.esus.name/esus/spin_paper/")
    print()
    
    # Show Bohr radius calculation
    verify_bohr_radius()
    
    # Show detailed examples
    analyze_element(1, "Hydrogen")
    analyze_element(6, "Carbon") 
    analyze_element(79, "Gold")
    
    # Show full periodic table results
    results = verify_all_elements()
    
    print("Unit verification:")
    print("  F = hbar^2/(gamma*m*r^3)")
    print("  [F] = [J*s]^2 / ([kg][m^3]) = [kg*m*s^-2] = [N]")
    print("  F = k*e^2/r^2") 
    print("  [F] = [N*m^2*C^-2][C^2] / [m^2] = [N]")
    print()
    
    # Show some key numbers for interpretation
    mean_ratio = np.mean([r['ratio'] for r in results])
    mean_deviation = np.mean([r['deviation_ppb'] for r in results])
    
    print("Key numbers:")
    print(f"  Mean force ratio across 100 elements: {mean_ratio:.15f}")
    print(f"  Deviation from unity: {abs(1-mean_ratio)*1e9:.3f} ppb")
    print(f"  Expected if identical: 0.000 ppb")
    print(f"  CODATA electron mass uncertainty: ~300 ppb")

if __name__ == "__main__":
    if len(sys.argv) > 1:
        if sys.argv[1] in ['-h', '--help']:
            print("Usage: python clean_numbers_only_script.py [element_Z]")
            print("Shows only calculated numbers, no conclusions")
            sys.exit(0)
        elif sys.argv[1].isdigit():
            Z = int(sys.argv[1])
            if 1 <= Z <= 100:
                print("Single element calculation:")
                analyze_element(Z, f"Element Z={Z}")
            else:
                print("Error: Z must be between 1 and 100")
                sys.exit(1)
        else:
            print("Error: Invalid argument")
            sys.exit(1)
    else:
        main()