Master Calculator — Al-Hindara Project

1. Z(x) Calculator (Frame 1)

Warning: Results are a partial sum over the first N zeros.

Definitions: Z_N(x) = -Σ 2x/(x²+γₖ²) | w_proxy = -1 + Z'''/Z' (experimental) | A = -0.011139 | C(x) = 1 - Z - A.

🔍 Data Source: Odlyzko, zeros1 — First 100 zeros, rounded to 15 decimal places. The seven anchors below are an internal consistency check, not a full external audit.

x:
N (1-100):

Y-axis scaling: Z(x) × 1 | Z'(x) × 100 | w_proxy ÷ 5

Display Curve:

x	Z_N(x)	Z′_N(x)	Z″_N(x)	w_proxy	C(x)

2. Bridge

A numerical multiplication process, not a physical derivation.

Value:
Factor:

3. The Tree and the Shadow (Frame 2)

\(\theta\) from vertical, \(S/H = \tan\theta\).

H (meters):
θ (0 ≤ θ < 90):

4. Frame 3 — \(R_{13/12}\)

Numerical ratio. 0.60352 is a comparison target, not a proof. Numerical stability ≠ model validity.

x_p:

python · verification_frame3.py

import numpy as np
from scipy.integrate import quad

def g(u, xp=21.0):
    if u <= 0 or u >= 2*np.pi: return 0.0
    return (u/(2*np.pi))**5 * np.log(2*np.pi/u) * np.exp(-2*np.pi/(xp*u))

def Y(n, u): return np.sin(n*u/2.0)
def D(u): return np.cos(u/2.0)

xp = 21
N1 = quad(lambda u: (g(u,xp)*Y(1,u))**2, 0, 2*np.pi, limit=300)[0]
N2 = quad(lambda u: (g(u,xp)*Y(2,u))**2, 0, 2*np.pi, limit=300)[0]
N3 = quad(lambda u: (g(u,xp)*Y(3,u))**2, 0, 2*np.pi, limit=300)[0]

A12 = quad(lambda u: (g(u,xp)*Y(1,u)/np.sqrt(N1)) * D(u) * (g(u,xp)*Y(2,u)/np.sqrt(N2)), 0, 2*np.pi, limit=300)[0]
A13 = quad(lambda u: (g(u,xp)*Y(1,u)/np.sqrt(N1)) * D(u) * (g(u,xp)*Y(3,u)/np.sqrt(N3)), 0, 2*np.pi, limit=300)[0]

R = (A13/A12)**2
print(f"N1 = {N1:.10e}")
print(f"N2 = {N2:.10e}")
print(f"N3 = {N3:.10e}")
print(f"A12 = {A12:.10e}")
print(f"A13 = {A13:.10e}")
print(f"R   = {R:.10f}")
print(f"Target error = {abs(R - 0.60352):.3e}")

5. Frame 4 — Verification

\(Lg = -g'' + (g''/g)g = 0\) is an algebraic identity. The test below compares a numerical derivative with the analytical formula, not a spectral test.

python · verification_frame4.py

import numpy as np

def g(u, xp=21.0):
    """Envelope function"""
    return (u/(2*np.pi))**5 * np.log(2*np.pi/u) * np.exp(-2*np.pi/(xp*u))

def p(u, xp=21.0):
    """p = g'/g"""
    ell = np.log(2*np.pi/u)
    a = 2*np.pi/xp
    return 5/u - 1/(u*ell) + a/(u**2)

def dp(u, xp=21.0):
    """p' = d/du(g'/g)"""
    ell = np.log(2*np.pi/u)
    a = 2*np.pi/xp
    return -5/u**2 + (ell-1)/(u**2*ell**2) - 2*a/u**3

def g_second_analytic(u, xp=21.0):
    """g'' analytically = g * (p^2 + p')"""
    return g(u,xp) * (p(u,xp)**2 + dp(u,xp))

def g_second_numeric(u, xp=21.0, h=1e-5):
    """g'' numerically via central differences"""
    return (g(u+h,xp) - 2*g(u,xp) + g(u-h,xp)) / (h**2)

u, xp, h = 1.0, 21.0, 1e-5

gu = g(u, xp)
gpp_num = g_second_numeric(u, xp, h)
gpp_ana = g_second_analytic(u, xp)

print(f"u = {u}, xp = {xp}, h = {h}")
print(f"g(u)              = {gu:.10e}")
print(f"g'' (numeric)     = {gpp_num:.10e}")
print(f"g'' (analytic)    = {gpp_ana:.10e}")
print(f"derivative diff   = {abs(gpp_num - gpp_ana):.4e}")
print()
print("Identity check: -g'' + (g''/g)*g = 0, where g != 0.")
print("This is an algebraic identity, not a spectral verification.")