mirror of
https://github.com/allaunthefox/Research-Stack.git
synced 2026-07-31 03:05:21 +00:00
139 lines
4.8 KiB
Python
139 lines
4.8 KiB
Python
#!/usr/bin/env python3
|
|
"""Golden Braid Centering Gate.
|
|
|
|
Computes Fibonacci/golden-ratio centering receipts for BraidStorm strand states.
|
|
This is a calibration and scar/coarsening detector, not a solver.
|
|
"""
|
|
from __future__ import annotations
|
|
import argparse, hashlib, json, math
|
|
from pathlib import Path
|
|
from typing import Any
|
|
|
|
PHI = (1.0 + math.sqrt(5.0)) / 2.0
|
|
INV_PHI = 1.0 / PHI
|
|
|
|
|
|
def sha256_json(value: Any) -> str:
|
|
payload=json.dumps(value, sort_keys=True, separators=(",", ":")).encode("utf-8")
|
|
return hashlib.sha256(payload).hexdigest()
|
|
|
|
|
|
def norm(v: list[float]) -> float:
|
|
return math.sqrt(sum(float(x)*float(x) for x in v))
|
|
|
|
|
|
def sub(a: list[float], b: list[float]) -> list[float]:
|
|
return [float(x)-float(y) for x,y in zip(a,b)]
|
|
|
|
|
|
def add(a: list[float], b: list[float]) -> list[float]:
|
|
return [float(x)+float(y) for x,y in zip(a,b)]
|
|
|
|
|
|
def scale(k: float, v: list[float]) -> list[float]:
|
|
return [float(k)*float(x) for x in v]
|
|
|
|
|
|
def golden_pull(state: list[float], center: list[float]) -> list[float]:
|
|
return add(center, scale(INV_PHI, sub(state, center)))
|
|
|
|
|
|
def mean(states: list[list[float]]) -> list[float]:
|
|
if not states:
|
|
return []
|
|
n=len(states); d=len(states[0])
|
|
return [sum(float(s[i]) for s in states)/n for i in range(d)]
|
|
|
|
|
|
def covariance_diag(states: list[list[float]]) -> list[float]:
|
|
if not states:
|
|
return []
|
|
m=mean(states)
|
|
n=len(states); d=len(states[0])
|
|
return [sum((float(s[i])-m[i])**2 for s in states)/n for i in range(d)]
|
|
|
|
|
|
def anisotropy(diag: list[float]) -> float:
|
|
if not diag:
|
|
return 0.0
|
|
avg=sum(diag)/len(diag)
|
|
return math.sqrt(sum((x-avg)**2 for x in diag)/len(diag))
|
|
|
|
|
|
def strand_receipt(before: list[float], after: list[float], center: list[float], steps: int = 1) -> dict[str, Any]:
|
|
d0=norm(sub(before, center))
|
|
d1=norm(sub(after, center))
|
|
expected=(INV_PHI**steps)
|
|
ratio=0.0 if d0 == 0 else d1/d0
|
|
residual=abs(ratio-expected)
|
|
return {"distance_before": d0, "distance_after": d1, "expected_ratio": expected, "actual_ratio": ratio, "golden_residual": residual}
|
|
|
|
|
|
def run(config: dict[str, Any]) -> dict[str, Any]:
|
|
center=[float(x) for x in config.get("center", [0.0]*16)]
|
|
strands=config.get("strands", [])
|
|
threshold=float(config.get("golden_threshold", 1e-6))
|
|
steps=int(config.get("steps", 1))
|
|
|
|
receipts=[]
|
|
after_states=[]
|
|
for s in strands:
|
|
before=[float(x) for x in s.get("state", [])]
|
|
if not before:
|
|
before=[0.0]*len(center)
|
|
after=[float(x) for x in s.get("after", golden_pull(before, center))]
|
|
after_states.append(after)
|
|
r=strand_receipt(before, after, center, steps=steps)
|
|
r.update({
|
|
"strand_id": s.get("id", sha256_json(before)[:12]),
|
|
"scar_class": "PASS_CENTERING" if r["golden_residual"] <= threshold else "CENTERING_SCAR",
|
|
"coarsening_agent": None if r["golden_residual"] <= threshold else {
|
|
"type": "golden_centering_failure",
|
|
"action": "downweight_fine_search_for_this_strand_or_crossing",
|
|
"reason": "strand did not contract at expected phi^-1 rate"
|
|
}
|
|
})
|
|
r["receipt_hash"] = sha256_json(r)
|
|
receipts.append(r)
|
|
|
|
bary=mean(after_states)
|
|
diag=covariance_diag(after_states)
|
|
omega_center=sum(r["golden_residual"] for r in receipts) + norm(sub(bary, center)) + anisotropy(diag)
|
|
|
|
receipt={
|
|
"receipt_type": "famm_golden_braid_centering_receipt",
|
|
"schema_version": "0.1.0",
|
|
"phi": PHI,
|
|
"inverse_phi": INV_PHI,
|
|
"center": center,
|
|
"threshold": threshold,
|
|
"strand_receipts": receipts,
|
|
"multi_strand": {
|
|
"barycenter": bary,
|
|
"covariance_diag": diag,
|
|
"covariance_anisotropy": anisotropy(diag),
|
|
"omega_center": omega_center,
|
|
"failed_count": sum(1 for r in receipts if r["scar_class"] != "PASS_CENTERING")
|
|
},
|
|
"no_drift_boundary": "Golden centering is a calibration/scar detector, not a solver. The endpoint is trivial; the collapse receipt is the useful artifact."
|
|
}
|
|
receipt["receipt_hash"]=sha256_json(receipt)
|
|
return receipt
|
|
|
|
|
|
def main() -> None:
|
|
parser=argparse.ArgumentParser()
|
|
parser.add_argument("--config", required=True)
|
|
parser.add_argument("--out", required=True)
|
|
args=parser.parse_args()
|
|
config=json.loads(Path(args.config).read_text(encoding="utf-8"))
|
|
receipt=run(config)
|
|
out=Path(args.out); out.parent.mkdir(parents=True, exist_ok=True)
|
|
out.write_text(json.dumps(receipt, indent=2, sort_keys=True), encoding="utf-8")
|
|
print(f"Wrote {out}")
|
|
print(f"Failed count: {receipt['multi_strand']['failed_count']}")
|
|
print(f"Omega center: {receipt['multi_strand']['omega_center']}")
|
|
print(f"Receipt hash: {receipt['receipt_hash']}")
|
|
|
|
if __name__ == "__main__":
|
|
main()
|