Reproducible source and supporting text for the associated calculation.
View complete source excerpt
"""Vary the algebraic count action forward, retaining actual spatial jets."""
from datetime import datetime, timezone
from fractions import Fraction
from hashlib import sha256
from importlib.util import spec_from_file_location, module_from_spec
from math import comb, factorial
from pathlib import Path
import json
import mpmath as mp
import numpy as np
import sympy as sp
ROOT = Path(__file__).resolve().parent
spec = spec_from_file_location('orientation', ROOT/'excited-shell-orientation-current.py')
orientation = module_from_spec(spec)
spec.loader.exec_module(orientation)
radial = orientation.radial
COUNTS, ERRORS = {}, {}
def check(value, label):
if not bool(value):
raise AssertionError(label)
COUNTS[label] = COUNTS.get(label, 0)+1
def close(actual, expected, label, tolerance=3e-8):
error = float(np.linalg.norm(np.asarray(actual)-np.asarray(expected))/max(1., np.linalg.norm(expected)))
ERRORS[label] = max(ERRORS.get(label, 0.), error)
check(error < tolerance, label)
def count_data(depth, level):
count = Fraction(comb(level+depth, depth))
reciprocals = [Fraction(1, level+j) for j in range(1, depth+1)]
first = count*sum(reciprocals)
second = count*(sum(reciprocals)**2-sum(v*v for v in reciprocals))
return count, first, second
def polynomial(depth, chi):
return np.prod([chi+j-depth/2 for j in range(1, depth+1)])/factorial(depth)
def bilinears(field, alpha, beta):
rho = np.vdot(field, field).real
scalar = np.vdot(field, beta@field).real
current = np.array([np.vdot(field, a@field).real for a in alpha])
norm = np.sqrt(rho*rho-current@current)
support = np.sqrt((rho-scalar)*(rho+scalar)-current@current)
return rho, scalar, current, norm, support
def potential(field, chi, epsilon, alpha, beta, depth):
_, _, _, norm, support = bilinears(field, alpha, beta)
return epsilon*norm*polynomial(depth, chi)-chi*support
def source(field, chi, epsilon, alpha, beta, depth):
rho, scalar, current, norm, support = bilinears(field, alpha, beta)
m = chi*scalar/support
eta = epsilon*polynomial(depth, chi)-chi*norm/support
return m*beta@field+eta/norm*(rho*field-sum(j*a@field for j, a in zip(current, alpha)))
def symbolic_forward_variation():
h, chi, c, y, epsilon = sp.symbols('h chi c y epsilon', positive=True)
p = sp.Function('P')
energy = h*c+epsilon*p(chi)-chi*sp.sqrt(c*c+y*y)
check(sp.simplify(sp.diff(energy, c).subs(y, 0)-(h-chi)) == 0,
'forward polarization variation locks the auxiliary label to the actual spatial eigenvalue')
check(sp.simplify(sp.diff(energy, chi).subs(y, 0)-(epsilon*sp.diff(p(chi), chi)-c)) == 0,
'forward auxiliary variation fixes the polarization by the derivative of the spatial count')
check(sp.simplify(energy.subs({chi: h, y: 0})-epsilon*p(h)) == 0,
'the complete stationary energy reduces to the count without discarding spatial kinetics')
check(sp.diff(energy, y).subs(y, 0) == 0,
'the retained relative-phase equation is stationary on the real pair')
check(sp.simplify(sp.diff(energy, y, 2).subs({chi: h, y: 0})+h/c) == 0,
'the forward action retains the original relative-phase curvature')
check(sp.simplify(-sp.diff(energy, c, chi)**2/sp.diff(energy, chi, 2)).subs(y, 0)
== -1/(epsilon*sp.diff(p(chi), chi, 2)),
'eliminating the algebraic variable retains the original polarization curvature')
def main():
symbolic_forward_variation()
mp.mp.dps = 85
rng = np.random.default_rng(202610120744)
epsilon_exact = {d: Fraction(3, 10)/max(count_data(d, n-1)[1]
for _, dd, n in radial.ASSIGNMENTS if dd == d) for d in radial.DEPTHS}
cases = []
for name, depth, index in radial.ASSIGNMENTS:
level, h = index-1, Fraction(2*(index-1)+depth, 2)
count, first, second = count_data(depth, level)
epsq, cq = epsilon_exact[depth], epsilon_exact[depth]*first
check(0 < cq < 1 and second > 0, 'one sector comparison scale keeps every inferred shell in the convex open chart')
def high(value):
return mp.mpf(value.numerator)/value.denominator
eps, ch, hh = high(epsq), high(cq), high(h)
def count_function(label):
return mp.fprod(label+j-mp.mpf(depth)/2 for j in range(1, depth+1))/factorial(depth)
def reduced_energy(polarization, label, phase):
return hh*polarization+eps*count_function(label)-label*mp.sqrt(polarization**2+phase**2)
def stationary_equations(polarization, label, phase):
return (mp.diff(lambda cc: reduced_energy(cc, label, phase), polarization),
mp.diff(lambda zz: reduced_energy(polarization, zz, phase), label),
mp.diff(lambda yy: reduced_energy(polarization, label, yy), phase))
solved = mp.findroot(stationary_equations, (ch*mp.mpf('.83'), hh*mp.mpf('.97'), ch*mp.mpf('.05')),
tol=mp.mpf('1e-72'), maxsteps=30)
check(mp.norm(solved-mp.matrix([ch, hh, 0])) < mp.mpf('1e-65'),
'independent simultaneous stationary solve recovers the geometric label polarization and relative phase')
check(abs(reduced_energy(*solved)-eps*high(count))/(eps*high(count)) < mp.mpf('1e-65'),
'independent stationary energy evaluation recovers the count clock relatively')
enumerated = sum(comb(k+depth-1, depth-1) for k in range(level+1))
check(enumerated == count,
'independent cumulative spatial shell enumeration gives the constitutive count at the solved label')
xx = mp.sqrt(1-ch*ch)
aa, bb = mp.sqrt((1+ch)/2), mp.sqrt((1-ch)/2)
mass_source = hh*xx/ch
eta = eps*high(count)-hh/ch
omega = eps*high(count)
pair = mp.matrix([aa, bb])
pair_h = mp.matrix([[hh+eta, mass_source], [mass_source, -hh+eta]])
relative_residual = mp.norm(pair_h*pair-omega*pair)/omega
check(relative_residual < mp.mpf('1e-65'), 'high precision complete pair equation verifies the selected count clock relatively')
check(abs(hh*ch+eps*high(count)-hh*ch-omega) < mp.mpf('1e-75'),
'high precision complete pair energy retains the spatial kinetic contribution')
generators = radial.gammas(depth+1)
alpha, beta = generators[:depth], generators[depth]
rank, eye = len(beta), np.eye(len(beta))
ep = float(eps)
for sample in range(3):
field = rng.normal(size=(rank, rank))+1j*rng.normal(size=(rank, rank))
field /= np.linalg.norm(field)
variation = rng.normal(size=field.shape)+1j*rng.normal(size=field.shape)
variation /= np.linalg.norm(variation)
chi, dc = float(h)+.17, .31
step = 2e-6
rho, scalar, current, norm, support = bilinears(field, alpha, beta)
factors = [chi+j-depth/2 for j in range(1, depth+1)]
derivative = polynomial(depth, chi)*sum(1/v for v in factors)
expected = 2*np.vdot(variation, source(field, chi, ep, alpha, beta, depth)).real
expected += dc*(ep*norm*derivative-support)
fd = (potential(field+step*variation, chi+step*dc, ep, alpha, beta, depth)
-potential(field-step*variation, chi-step*dc, ep, alpha, beta, depth))/(2*step)
close(fd/max(1., chi), expected/max(1., chi),
'independent arbitrary field and auxiliary variations verify the complete local source')
direction = rng.normal(size=depth); direction /= np.linalg.norm(direction)
al = sum(v*a for v, a in zip(direction, alpha))
rapidity = .47
spin = np.cosh(rapidity/2)*eye+np.sinh(rapidity/2)*al
close(potential(spin@field, chi, ep, alpha, beta, depth),
potential(field, chi, ep, alpha, beta, depth),
'actual spinor boosts preserve the one-field count potential')
position = rng.normal(size=depth+1); position /= np.linalg.norm(position)
frame, _ = np.linalg.qr(np.column_stack([position, rng.normal(size=(depth+1, depth))]))
t, v = position[0], frame[0, 1:]
av = sum(vi*a for vi, a in zip(v, alpha))
a, b, ap, bp = orientation.polynomials(depth, level, np.array(t))
matrix = a*eye-1j*b*av
jets = [(ap*v[i]*eye-1j*(bp*v[i]*av-t*b*al)+.5j*matrix@al)
for i, al in enumerate(alpha)]
dmatrix = -1j*sum(al@jet for al, jet in zip(alpha, jets))
close(dmatrix, float(h)*matrix, 'actual covariant Clifford jets verify the spatial eigenvalue entering the forward derivation')
field = (float(aa)*eye+float(bb)*beta)@matrix
field /= np.linalg.norm(field)
dfield = (float(aa)*eye-float(bb)*beta)@dmatrix/np.linalg.norm((float(aa)*eye+float(bb)*beta)@matrix)
full = dfield+source(field, float(h), ep, alpha, beta, depth)
close(full/float(hh/ch), float(omega)*field/float(hh/ch),
'actual full local field source and spatial jet satisfy the selected stationary branch', 3e-6)
cases.append(dict(particle=name, depth=depth, inferred_index=index,
auxiliary_label_exact=str(h), count_exact=str(count),
epsilon_exact=str(epsq), polarization_exact=str(cq),
frequency_in_radius_units_exact=str(epsq*count),
pair_clock_relative_residual=str(relative_residual),
source_coefficient=float(mass_source),
eliminated_polarization_curvature_exact=str(-1/(epsq*second)),
classification='forward conditional derivation from the explicit count constitutive action'))
print(json.dumps(dict(completed=name, depth=depth, count=int(count))), flush=True)
stamp = datetime.now(timezone.utc).strftime('%Y%m%dT%H%M%S.%fZ')
report = dict(experiment_key='forward-algebraic-count-action', created_utc=datetime.now(timezone.utc).isoformat(),
sources={'experiments/'+p.name: sha256(p.read_bytes()).hexdigest() for p in
[Path(__file__), ROOT/'inverse-current-radial.py', ROOT/'excited-shell-orientation-current.py']},
evaluations=sum(COUNTS.values()), conditions=COUNTS, maximum_errors=ERRORS, cases=cases,
limits=['the spatial counting constitutive potential is a stated premise recovered by inverse research',
'the algebraic label adds no propagating field or mediator',
'this action is equivalent to the raw inverse-current law, not its flattened persistence modification',
'spatial jet residuals are scaled by the large source coefficient; pair clocks are checked relatively at high precision',
'the conditional sphere, sector scales, sparse occupation and localized support are not derived here',
'no new assigned-depth preference, observed particle identification or additional persistence theorem follows'])
output = ROOT/('forward-count-action-results-'+stamp+'.json')
output.write_text(json.dumps(report, indent=2)+'\n')
print(json.dumps(dict(report=str(output), evaluations=report['evaluations'], maximum_errors=ERRORS)), flush=True)
if __name__ == '__main__':
main()