mirror of
https://github.com/allaunthefox/Research-Stack.git
synced 2026-07-31 03:05:21 +00:00
allaun
475f6319ea
This squashes all local history (768 commits) onto the scrubbed PR #90 baseline. Individual commits were lost during filter-repo corruption; the working tree content is preserved intact. Build: N/A (working tree state only)
248 lines
10 KiB
Python
248 lines
10 KiB
Python
#!/usr/bin/env python3
|
|
"""Term-family eigen probe for the full Standard Model Lagrangian wall.
|
|
|
|
The source image is a compact Standard Model Lagrangian expansion. A physical
|
|
eigenvector would require an explicit operator, basis, gauge fixing, background,
|
|
renormalization scale, and boundary conditions. This probe instead builds a
|
|
receipt-bearing feature operator from visible term families and computes the
|
|
principal eigenvector of that coupling/interaction matrix.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import argparse
|
|
import hashlib
|
|
import json
|
|
import math
|
|
from datetime import datetime, timezone
|
|
from pathlib import Path
|
|
from typing import Any
|
|
|
|
|
|
REPO = Path(__file__).resolve().parents[2]
|
|
OUT = REPO / "4-Infrastructure" / "hardware" / "standard_model_lagrangian_eigen_probe_receipt.json"
|
|
PHI = (1.0 + math.sqrt(5.0)) / 2.0
|
|
|
|
|
|
NODES = [
|
|
"su3_gluon_field",
|
|
"nonabelian_self_interaction",
|
|
"electroweak_charged_w",
|
|
"electroweak_neutral_za",
|
|
"higgs_goldstone_scalar",
|
|
"scalar_potential",
|
|
"fermion_quark_sector",
|
|
"fermion_lepton_sector",
|
|
"yukawa_mass_coupling",
|
|
"charged_current_ckm",
|
|
"ghost_gaugefix_sector",
|
|
"derivative_kinetic_flow",
|
|
]
|
|
|
|
|
|
# Manual term-family observations from the visible Lagrangian wall. These are
|
|
# not physical coupling constants; they are a compact feature grammar for the
|
|
# printed expansion.
|
|
OBSERVATIONS: list[tuple[str, str, float, str]] = [
|
|
("su3_gluon_field", "nonabelian_self_interaction", 8.0, "G kinetic, g_s f GGG, and g_s^2 f f GGGG terms"),
|
|
("su3_gluon_field", "derivative_kinetic_flow", 5.0, "partial_mu G partial^mu G and derivative gluon terms"),
|
|
("electroweak_charged_w", "nonabelian_self_interaction", 7.0, "W+ W- cubic and quartic gauge self terms"),
|
|
("electroweak_charged_w", "electroweak_neutral_za", 9.0, "A/Z with W+ W- mixing and c_w/s_w factors"),
|
|
("electroweak_neutral_za", "derivative_kinetic_flow", 6.0, "Z/A derivative kinetic and mixed derivative terms"),
|
|
("electroweak_charged_w", "derivative_kinetic_flow", 6.0, "W derivative kinetic and cross-derivative terms"),
|
|
("higgs_goldstone_scalar", "scalar_potential", 9.0, "H, phi0, phi+, phi- quartic and mass-potential terms"),
|
|
("higgs_goldstone_scalar", "electroweak_charged_w", 8.0, "W W H, W phi derivative, W W scalar terms"),
|
|
("higgs_goldstone_scalar", "electroweak_neutral_za", 7.0, "Z Z H, A/Z scalar derivative and scalar couplings"),
|
|
("higgs_goldstone_scalar", "derivative_kinetic_flow", 5.0, "scalar derivative kinetic terms"),
|
|
("fermion_quark_sector", "electroweak_charged_w", 6.0, "W charged quark currents"),
|
|
("fermion_lepton_sector", "electroweak_charged_w", 5.0, "W charged lepton/neutrino currents"),
|
|
("fermion_quark_sector", "electroweak_neutral_za", 6.0, "A/Z quark neutral currents"),
|
|
("fermion_lepton_sector", "electroweak_neutral_za", 5.0, "A/Z lepton neutral currents"),
|
|
("fermion_quark_sector", "yukawa_mass_coupling", 7.0, "m_u, m_d, H, phi Yukawa-like terms"),
|
|
("fermion_lepton_sector", "yukawa_mass_coupling", 5.0, "m_e, m_nu, H, phi Yukawa-like terms"),
|
|
("charged_current_ckm", "fermion_quark_sector", 6.0, "C_lambda k charged current quark mixing"),
|
|
("charged_current_ckm", "electroweak_charged_w", 5.0, "W+/- CKM charged current coupling"),
|
|
("ghost_gaugefix_sector", "electroweak_charged_w", 5.0, "X+/X- ghosts coupled to W"),
|
|
("ghost_gaugefix_sector", "electroweak_neutral_za", 4.0, "X0/Y ghosts and neutral gauge couplings"),
|
|
("ghost_gaugefix_sector", "higgs_goldstone_scalar", 4.0, "ghost-Higgs/Goldstone terms"),
|
|
("ghost_gaugefix_sector", "derivative_kinetic_flow", 4.0, "ghost kinetic derivative terms"),
|
|
("yukawa_mass_coupling", "higgs_goldstone_scalar", 8.0, "H and phi insertions into fermion mass terms"),
|
|
("scalar_potential", "electroweak_charged_w", 3.0, "scalar-gauge mass-generated W couplings"),
|
|
("scalar_potential", "electroweak_neutral_za", 3.0, "scalar-gauge mass-generated Z/A couplings"),
|
|
]
|
|
|
|
|
|
def stable_json(obj: Any) -> str:
|
|
return json.dumps(obj, sort_keys=True, separators=(",", ":"), ensure_ascii=True)
|
|
|
|
|
|
def sha256_bytes(data: bytes) -> str:
|
|
return hashlib.sha256(data).hexdigest()
|
|
|
|
|
|
def build_matrix(phi_mode: str) -> list[list[float]]:
|
|
index = {name: pos for pos, name in enumerate(NODES)}
|
|
size = len(NODES)
|
|
matrix = [[0.0 for _ in range(size)] for _ in range(size)]
|
|
for left, right, weight, _note in OBSERVATIONS:
|
|
i = index[left]
|
|
j = index[right]
|
|
if phi_mode == "none":
|
|
adjusted = weight
|
|
elif phi_mode == "sector_scale":
|
|
adjusted = weight * (PHI if "higgs" in left or "higgs" in right or "scalar" in left or "scalar" in right else 1.0)
|
|
elif phi_mode == "omni":
|
|
adjusted = weight * (PHI ** (((i + j) % 5) / 4.0))
|
|
else:
|
|
raise ValueError(f"unknown phi mode: {phi_mode}")
|
|
matrix[i][j] += adjusted
|
|
matrix[j][i] += adjusted
|
|
# Diagonal mass/self weights keep each sector visible in the operator.
|
|
for i, name in enumerate(NODES):
|
|
base = 1.0 + sum(matrix[i]) / 20.0
|
|
if phi_mode == "omni":
|
|
base *= PHI ** ((i % 3) / 3.0)
|
|
matrix[i][i] = base
|
|
return matrix
|
|
|
|
|
|
def matvec(matrix: list[list[float]], vector: list[float]) -> list[float]:
|
|
return [sum(row[j] * vector[j] for j in range(len(vector))) for row in matrix]
|
|
|
|
|
|
def norm(vector: list[float]) -> float:
|
|
return math.sqrt(sum(value * value for value in vector))
|
|
|
|
|
|
def principal_eigen(matrix: list[list[float]], iterations: int = 256) -> dict[str, Any]:
|
|
size = len(matrix)
|
|
vector = [1.0 / math.sqrt(size) for _ in range(size)]
|
|
eigenvalue = 0.0
|
|
for _ in range(iterations):
|
|
nxt = matvec(matrix, vector)
|
|
nrm = norm(nxt)
|
|
if nrm == 0.0:
|
|
break
|
|
vector = [value / nrm for value in nxt]
|
|
av = matvec(matrix, vector)
|
|
eigenvalue = sum(vector[i] * av[i] for i in range(size))
|
|
residual_vec = [matvec(matrix, vector)[i] - eigenvalue * vector[i] for i in range(size)]
|
|
return {
|
|
"eigenvalue": eigenvalue,
|
|
"vector": vector,
|
|
"residual_norm": norm(residual_vec),
|
|
"iterations": iterations,
|
|
}
|
|
|
|
|
|
def summarize_vector(vector: list[float]) -> list[dict[str, float | str]]:
|
|
entries = [
|
|
{"node": node, "component": vector[i], "abs_component": abs(vector[i])}
|
|
for i, node in enumerate(NODES)
|
|
]
|
|
return sorted(entries, key=lambda item: float(item["abs_component"]), reverse=True)
|
|
|
|
|
|
def spectral_gap_proxy(matrix: list[list[float]], principal: list[float], eigenvalue: float) -> float:
|
|
"""Crude deflation-based gap proxy for this receipt."""
|
|
size = len(matrix)
|
|
deflated = [
|
|
[
|
|
matrix[i][j] - eigenvalue * principal[i] * principal[j]
|
|
for j in range(size)
|
|
]
|
|
for i in range(size)
|
|
]
|
|
second = principal_eigen(deflated, iterations=128)["eigenvalue"]
|
|
return eigenvalue - abs(float(second))
|
|
|
|
|
|
def mode_result(phi_mode: str) -> dict[str, Any]:
|
|
matrix = build_matrix(phi_mode)
|
|
principal = principal_eigen(matrix)
|
|
entries = summarize_vector(principal["vector"])
|
|
gap = spectral_gap_proxy(matrix, principal["vector"], float(principal["eigenvalue"]))
|
|
matrix_hash = sha256_bytes(stable_json(matrix).encode("utf-8"))
|
|
vector_hash = sha256_bytes(stable_json(entries).encode("utf-8"))
|
|
return {
|
|
"phi_mode": phi_mode,
|
|
"matrix_hash_sha256": matrix_hash,
|
|
"vector_hash_sha256": vector_hash,
|
|
"principal_eigenvalue": principal["eigenvalue"],
|
|
"residual_norm": principal["residual_norm"],
|
|
"spectral_gap_proxy": gap,
|
|
"dominant_components": entries,
|
|
"claim_boundary": (
|
|
"Eigenvector is from a hand-extracted term-family feature matrix, "
|
|
"not from the physical Standard Model Hamiltonian or propagator."
|
|
),
|
|
}
|
|
|
|
|
|
def build_receipt() -> dict[str, Any]:
|
|
modes = [mode_result(mode) for mode in ("none", "sector_scale", "omni")]
|
|
receipt = {
|
|
"schema": "standard_model_lagrangian_term_eigen_probe_v1",
|
|
"generated_utc": datetime.now(timezone.utc).isoformat(),
|
|
"surface_id": "standard_model_lagrangian_wall_eigen_probe",
|
|
"source": {
|
|
"description": "User-provided image of expanded Standard Model Lagrangian.",
|
|
"visible_term_families": NODES,
|
|
"observation_count": len(OBSERVATIONS),
|
|
"observations": [
|
|
{"left": left, "right": right, "weight": weight, "note": note}
|
|
for left, right, weight, note in OBSERVATIONS
|
|
],
|
|
},
|
|
"phi": PHI,
|
|
"modes": modes,
|
|
"lawful": True,
|
|
"claim_boundary": (
|
|
"This probe computes eigenvectors of a term-family interaction matrix "
|
|
"derived from the visible Lagrangian wall. It does not compute particle "
|
|
"mass eigenstates, CKM/PMNS eigenvectors, beta functions, vacuum states, "
|
|
"or a physical spectrum."
|
|
),
|
|
}
|
|
stable_preimage = stable_json({
|
|
"schema": receipt["schema"],
|
|
"surface_id": receipt["surface_id"],
|
|
"source": receipt["source"],
|
|
"phi": receipt["phi"],
|
|
"modes": receipt["modes"],
|
|
"lawful": receipt["lawful"],
|
|
"claim_boundary": receipt["claim_boundary"],
|
|
}).encode("utf-8")
|
|
receipt["stable_probe_hash_sha256"] = sha256_bytes(stable_preimage)
|
|
receipt["receipt_hash_preimage_sha256"] = sha256_bytes(stable_json(receipt).encode("utf-8"))
|
|
return receipt
|
|
|
|
|
|
def main() -> int:
|
|
parser = argparse.ArgumentParser(description=__doc__)
|
|
parser.add_argument("--out", type=Path, default=OUT)
|
|
args = parser.parse_args()
|
|
receipt = build_receipt()
|
|
args.out.parent.mkdir(parents=True, exist_ok=True)
|
|
args.out.write_text(json.dumps(receipt, indent=2, sort_keys=True), encoding="utf-8")
|
|
print(json.dumps({
|
|
"lawful": receipt["lawful"],
|
|
"stable_probe_hash_sha256": receipt["stable_probe_hash_sha256"],
|
|
"receipt_hash_preimage_sha256": receipt["receipt_hash_preimage_sha256"],
|
|
"modes": [
|
|
{
|
|
"phi_mode": mode["phi_mode"],
|
|
"principal_eigenvalue": mode["principal_eigenvalue"],
|
|
"residual_norm": mode["residual_norm"],
|
|
"spectral_gap_proxy": mode["spectral_gap_proxy"],
|
|
"top_component": mode["dominant_components"][0],
|
|
}
|
|
for mode in receipt["modes"]
|
|
],
|
|
"out": str(args.out.relative_to(REPO)) if args.out.is_relative_to(REPO) else str(args.out),
|
|
}, indent=2, sort_keys=True))
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
raise SystemExit(main())
|