#!/usr/bin/env python3
"""QTT AI Reader Protocol arithmetic audit.

Scope: selected encoded identities, reference-value reproduction, and comparator
arithmetic. A PASS does not validate the derivations, ontology, empirical inputs,
or the QTT research programme as a whole.
"""
import math
import sys

checks = []


def check(name, value, reference, relative_tolerance=1e-9):
    if reference == 0:
        passed = abs(value) < relative_tolerance
    else:
        passed = abs(value / reference - 1.0) < relative_tolerance
    checks.append(passed)
    tag = "PASS" if passed else "FAIL"
    print(f"[{tag}] {name}: {value:.12g} (reference {reference:.12g})")


hbar = 1.054571817e-34
c = 2.99792458e8
k_B = 1.380649e-23
gev_joule = 1.602176634e-10
G_cod = 6.6743e-11
u_relative_G = 2.2e-5
G_F = 1.1663787e-5
alpha_inverse_external_comparator = 137.035999177

rho = 2.0 * math.pi * math.cos(math.pi / 8.0)
check("rho = 2 pi cos(pi/8)", rho, 5.804906304278862)

q_H = 2.0 * math.exp(-4.0 * math.pi**2 - 1.0 / (8.0 * rho**2))
check("q_H scalar lock", q_H, 1.4261330508e-17, 1e-10)

lambda_gamma = (
    1.0 / (64.0 * rho)
    - 1.0 / (1024.0 * rho)
    - 1.0 / (24.0**2 * 64.0 * rho**2)
    - 1.0 / (24.0**2 * 64.0 * rho**4)
    + 1.0 / (24.0 * 8.0 * 32.0 * 64.0)
)
check("lambda_gamma closed expression", lambda_gamma, 0.00252517226324577, 1e-14)
alpha_qtt_inverse = 4.0 * math.pi * (8.0 + rho / 2.0 + lambda_gamma)
alpha_qtt = 1.0 / alpha_qtt_inverse
check("alpha_QTT inverse", alpha_qtt_inverse, 137.035999165998, 1e-12)

R_H = math.exp(
    -alpha_qtt
    / (8.0 * rho**2)
    * math.sqrt(6.0 + rho**-2)
)
check("R_H electroweak readout gate", R_H, 0.9999335312550867, 1e-12)
v = (math.sqrt(2.0) * G_F) ** -0.5
check("v from external G_F (GeV)", v, 246.219651, 1e-8)

E_star = v / (math.sqrt(2.0) * q_H * R_H)
check("E_star (GeV)", E_star, 1.220890e19, 1e-6)

ell_A = hbar * c / (E_star * gev_joule)
ell_G = math.sqrt(hbar * G_cod / c**3)
length_ppm = (ell_A / ell_G - 1.0) * 1e6
length_sigma = (ell_A / ell_G - 1.0) / (u_relative_G / 2.0)
print(
    f"[REPORT] ell_A = {ell_A:.10e} m; "
    f"external CODATA-G ruler difference = {length_ppm:+.4f} ppm "
    f"({length_sigma:+.4f} sigma under the encoded uncertainty)"
)
print("[SCOPE] The ppm value is a central-value offset, not measurement resolution or a QTT p-value.")
check("encoded ell_A comparator arithmetic (ppm)", length_ppm, 0.1055, 1e-4)

Q_sigma = 8.0 * math.pi * ell_A**2
eta = 2.0 * math.pi * k_B / Q_sigma
kappa_E = Q_sigma / (hbar * c)
G_A = kappa_E * c**4 / (8.0 * math.pi)
check("eta kappa_E hbar c / k_B = 2 pi", eta * kappa_E * hbar * c / k_B, 2.0 * math.pi, 1e-14)
check("hbar = c^3 Q_sigma / (8 pi G_A)", c**3 * Q_sigma / (8.0 * math.pi * G_A), hbar, 1e-14)
print(f"[REPORT] G_A = {G_A:.8e} m^3 kg^-1 s^-2; external CODATA difference = {(G_A/G_cod-1)*1e6:+.4f} ppm")

print(f"[REPORT] alpha inverse external comparator delta = {alpha_qtt_inverse-alpha_inverse_external_comparator:+.12g}")

electron, muon, tau = 0.51099895000, 105.6583755, 1776.86
koide = (electron + muon + tau) / (math.sqrt(electron) + math.sqrt(muon) + math.sqrt(tau)) ** 2
print(f"[REPORT] Koide expression from encoded mass inputs = {koide:.10f}; fractional delta from 2/3 = {(koide/(2/3)-1)*1e6:+.2f} ppm")

delta_nu_cs = 9192631770.0
a_A = ell_A * delta_nu_cs / c
R_infinity_c = 3.2898419602500e15
mu_proton_electron = 1836.15267342638
X_cs = delta_nu_cs / R_infinity_c
alpha_external = 1.0 / alpha_inverse_external_comparator
W_cs = X_cs / (alpha_external**2 / mu_proton_electron)
check("K2 bridge a_A", a_A, 4.9559748596e-34, 1e-9)
check("AMBER sealed W_Cs target arithmetic", W_cs, 96.348057, 1e-7)
check("AMBER sealed D_hat target arithmetic", W_cs / ((8.0 / 3.0) * (2.5820246 / 3.5)) / 4.0, 12.2440, 1e-4)

H_0 = 67.36 * 1000.0 / 3.0857e22
omega_lambda = 0.6847
H_lambda = math.sqrt(omega_lambda) * H_0
x = H_lambda * (ell_A / c)
check("AMBER sealed Lambda word x = H_Lambda t_A", x, 9.7384036697e-62, 1e-6)
check("epsilon = (9/2) x^2", 4.5 * x * x, 4.268e-122, 1e-3)
check(
    "horizon face epsilon N_H = (9 pi/2) Omega_Lambda",
    4.5 * x * x * math.pi / (H_0 * ell_A / c) ** 2,
    (9.0 * math.pi / 2.0) * omega_lambda,
    1e-12,
)

if all(checks):
    print("ARITHMETIC AUDIT PASS - ENCODED IDENTITIES AND COMPARATOR ARITHMETIC ONLY")
    sys.exit(0)

print("ARITHMETIC AUDIT FAIL - INSPECT FAIL LINES BEFORE USING THE LEDGER")
sys.exit(1)