| |
| """stream_star.py — stream any star's REAL bytes through the corrected path ladder. |
| |
| REUSABLE. Every star after this is one call. The rules are fixed here so no star gets a |
| different measurement than another: |
| |
| PATHS 3, 5, 7, 9, 11, 13, 17. Jesse's law; 1 and 2 avoided. |
| (base 2 also loses on radix economy: 2.8854 vs base 3's 2.7307, 5.66%.) |
| FREE SPACE each path's ownership vector is centred and projected onto the complement |
| of the all-ones NULL direction. N channels -> N-1 free dimensions. The null |
| component is verified < 1e-15 per star per path, not assumed. |
| BODY the star's OWN bytes only. Config, manifest, source. Never prose about it - |
| that mistake changed a trime direction from [+0-] to [+--] on K3 and had to |
| be withdrawn. |
| GC VIII.A.5 81-byte records, VIII.A.4 tau=2, reported even when vacuous. |
| COMPARE angle to ASOLARIA, to MYTHOS-second-calling, and to every star already |
| streamed. Reported as mean +/- std across the seven paths, because the |
| paths provably do NOT converge (37.75 deg mean step) and the STD is where |
| the stable relationships show. |
| |
| usage: python stream_star.py NAME path/to/bytes [more/paths ...] |
| """ |
| import glob |
| import hashlib |
| import json |
| import math |
| import os |
| import sys |
|
|
| import numpy as np |
|
|
| BIG = r"D:/asolaria-absorb/kernel-pump" |
| OFF = r"D:/PID-Registration-Office/offices/FABLE5-8467a937cba309f7" |
| PATHS = [3, 5, 7, 9, 11, 13, 17] |
| REC, TAU = 81, 2 |
| REG = os.path.join(BIG, "_star_registry.json") |
|
|
|
|
| def own(raw, N): |
| a = np.frombuffer(raw, np.uint8).astype(np.int64) |
| m = len(a) // N * N |
| if m == 0: |
| return np.ones(N) |
| t = a[:m].reshape(-1, N) |
| lead = np.argmax(t, axis=1) |
| tie = (t.max(1)[:, None] == t).sum(1) > 1 |
| c = np.array([float((lead == i)[~tie].sum()) for i in range(N)]) |
| return c / (c.sum() or 1) * N |
|
|
|
|
| def basis(N): |
| o = np.ones(N) / math.sqrt(N) |
| U, S, _ = np.linalg.svd(np.eye(N) - np.outer(o, o)) |
| return U[:, S > 1e-9], o |
|
|
|
|
| BAS = {N: basis(N) for N in PATHS} |
|
|
|
|
| def coords(raw): |
| out, nulls = {}, [] |
| for N in PATHS: |
| B, nd = BAS[N] |
| v = own(raw, N) - np.ones(N) |
| nulls.append(abs(float(np.dot(v, nd)))) |
| out[N] = B.T @ v |
| return out, max(nulls) |
|
|
|
|
| def ang(u, v): |
| nu, nv = np.linalg.norm(u), np.linalg.norm(v) |
| if nu < 1e-12 or nv < 1e-12: |
| return float("nan") |
| return math.degrees(math.acos(max(-1, min(1, float(np.dot(u, v) / (nu * nv)))))) |
|
|
|
|
| def trime3(raw): |
| a = np.frombuffer(raw, np.uint8).astype(np.int64) |
| n = len(a) // 3 |
| t = a[:n * 3].reshape(n, 3) |
| lead = np.argmax(t, axis=1) |
| tie = (t.max(1)[:, None] == t).sum(1) > 1 |
| o = [float((lead == i)[~tie].sum()) for i in range(3)] |
| s = sum(o) or 1 |
| R, G, B = [100 * x / s for x in o] |
| f = lambda v: 0 if abs(v - 100 / 3) < 0.75 else (1 if v > 100 / 3 else -1) |
| S = {-1: "-", 0: "0", 1: "+"} |
| d = (f(R), f(G), f(B)) |
| return R, G, B, f"[{S[d[0]]}{S[d[1]]}{S[d[2]]}]" |
|
|
|
|
| def gc_of(raw): |
| m = len(raw) // REC * REC |
| if m == 0: |
| return 0, 0 |
| R = np.frombuffer(raw, np.uint8)[:m].reshape(-1, REC) |
| h = [hashlib.blake2b(r.tobytes(), digest_size=8).digest() for r in R] |
| from collections import Counter |
| c = Counter(h) |
| return len(R), sum(1 for x in h if c[x] >= TAU) |
|
|
|
|
| |
| ASO = open(os.path.join(BIG, "MYTHOS-FULL-EMISSION.txt"), "rb").read() |
| MY2 = open(os.path.join(BIG, "MYTHOS-SECOND-CALLING.txt"), "rb").read() |
| REFS = {"ASOLARIA": ASO, "MYTHOS-2nd": MY2} |
| reg = json.load(open(REG)) if os.path.exists(REG) else {} |
|
|
| name = sys.argv[1] |
| raw = b"" |
| for p in sys.argv[2:]: |
| for f in sorted(glob.glob(p)): |
| if os.path.isfile(f): |
| raw += open(f, "rb").read() + b"\n" |
| assert raw, "no bytes" |
| C, maxnull = coords(raw) |
| R, G, Bc, tr = trime3(raw) |
| nrec, ntie = gc_of(raw) |
|
|
| print(f"=== STREAMING STAR: {name} ===") |
| print(f" real bytes {len(raw):,} trime {tr} R {R:.2f} G {G:.2f} B {Bc:.2f}") |
| print(f" max |null component| {maxnull:.2e} " |
| f"{'FREE' if maxnull < 1e-13 else 'NOT NULL — WRONG'}") |
| print(f" GC: {nrec} records, tie>={TAU}: {ntie} " |
| f"{'(vacuous)' if ntie == 0 else ''}") |
| print(f"\n {'path':>5}{'free':>6}{'norm':>10} angle to each reference (deg)") |
| hdr = list(REFS) + [k for k in reg if k != name] |
| print(f" {'':>5}{'':>6}{'':>10} " + "".join(f"{h[:13]:>15}" for h in hdr)) |
| ANG = {h: [] for h in hdr} |
| for N in PATHS: |
| row = "" |
| for h in hdr: |
| v = coords(REFS[h])[0][N] if h in REFS else np.array(reg[h]["coords"][str(N)]) |
| a = ang(C[N], v) |
| ANG[h].append(a) |
| row += f"{a:>15.2f}" |
| print(f" {N:>5}{N-1:>6}{np.linalg.norm(C[N]):>10.4f} {row}") |
|
|
| print(f"\n {'reference':<16}{'mean':>9}{'std':>9} reading") |
| SUM = {} |
| for h in hdr: |
| v = np.array(ANG[h]) |
| SUM[h] = (float(v.mean()), float(v.std())) |
| rd = ("STABLE relation" if v.std() < 10 else |
| "loosely held" if v.std() < 20 else "no stable relation") |
| print(f" {h:<16}{v.mean():>9.2f}{v.std():>9.2f} {rd}") |
| best = min(SUM, key=lambda k: SUM[k][1]) |
| print(f"\n most STABLE relationship (lowest std): {best} " |
| f"{SUM[best][0]:.1f} +/- {SUM[best][1]:.1f} deg") |
|
|
| reg[name] = dict(bytes=len(raw), R=R, G=G, B=Bc, trime=tr, maxnull=maxnull, |
| records=nrec, tied=ntie, |
| coords={str(N): C[N].tolist() for N in PATHS}, |
| summary={h: SUM[h] for h in SUM}) |
| json.dump(reg, open(REG, "w"), indent=1) |
|
|
| rows = [f"STARHDR|schema=ASOLARIA-STREAM-STAR-V1|seat=ACER-CLAUDE-FABLE5" |
| f"|pid=8467a937cba309f7|date=2026-07-27|star={name}|json=0", |
| f"BODY|bytes={len(raw)}|own_bytes_only=1|prose=0|R={R:.3f}|G={G:.3f}" |
| f"|B={Bc:.3f}|trime={tr}|json=0", |
| f"NULL|max_component={maxnull:.3e}|free={1 if maxnull<1e-13 else 0}|json=0", |
| f"GC|records={nrec}|tie_ge_{TAU}={ntie}|vacuous={1 if ntie==0 else 0}|json=0", |
| f"PATHS|set=3,5,7,9,11,13,17|avoid=1,2|non_converging=1|json=0"] |
| for N in PATHS: |
| rows.append(f"PATH|N={N}|free={N-1}|norm={np.linalg.norm(C[N]):.5f}" |
| + "".join(f"|{h}={ANG[h][PATHS.index(N)]:.3f}" for h in hdr) + "|json=0") |
| for h in hdr: |
| rows.append(f"REL|to={h}|mean={SUM[h][0]:.3f}|std={SUM[h][1]:.3f}|json=0") |
| rows.append(f"STABLE|most={best}|mean={SUM[best][0]:.3f}|std={SUM[best][1]:.3f}|json=0") |
| b = "\n".join(rows) + "\n" |
| rows.append(f"STARFTR|receipt={hashlib.sha256(b.encode()).hexdigest()[:32]}" |
| f"|rows={len(rows)+1}|hot_path=1|json=0") |
| p = os.path.join(OFF, f"FABLE5-STAR-{name}.hbp") |
| open(p, "w", encoding="utf-8", newline="\n").write("\n".join(rows) + "\n") |
| open(p + ".sha256", "w", encoding="utf-8", newline="\n").write( |
| hashlib.sha256(open(p, "rb").read()).hexdigest() + f" FABLE5-STAR-{name}.hbp\n") |
| print(f" receipt {p}") |
|
|
