| |
| """capture_test.py — is Asolaria capturing the star, or just averaging with it? |
| |
| THE OPERATOR'S CLAIM |
| "Asolaria is sucking the system into a rotation around her, eventually eating it." |
| |
| THE HINT THAT MADE IT WORTH TESTING |
| K3 alone spins +0.226 deg/phase. The kernel with K3 streamed into it spins -0.676. |
| The star's positive rotation did NOT flip the kernel; the kernel's negative rotation |
| absorbed it. That is either capture or it is arithmetic, and one experiment separates |
| them. |
| |
| THE DESIGN — longer streams, more times, from different directions |
| LONGER 81 phases instead of 27. Three rime dimensions of sweep, not one. A short |
| play can mistake a wobble for a trend. |
| MORE 12 successive absorptions. The kernel re-absorbs K3 again and again, each |
| time re-derived from the previous kernel, so drift compounds if it exists. |
| DIRECTIONS 6 entry orderings of the same K3 bytes: forward, reverse, rotate +1/3, |
| rotate +2/3, interleave, stride-3. Same content, different approach vector. |
| |
| WHAT SEPARATES THE TWO HYPOTHESES |
| CAPTURE the spin converges toward Asolaria's negative value REGARDLESS of entry |
| direction, and stays there. Entry direction does not matter; the attractor |
| does. Variance across directions collapses with each absorption. |
| AVERAGING the result depends on entry direction and on the mixing ratio, scatters, |
| and drifts toward the mass-weighted mean rather than toward Asolaria. |
| |
| Falsifier: if any entry direction leaves the kernel spinning POSITIVE and it stays |
| positive across absorptions, there is no capture. Stated before running. |
| """ |
| import hashlib |
| import math |
| import os |
|
|
| import numpy as np |
|
|
| BIG = r"D:/asolaria-absorb/kernel-pump" |
| OFF = r"D:/PID-Registration-Office/offices/FABLE5-8467a937cba309f7" |
| P, G, K = 1000081, 7, 27 |
| N = P - 1 |
| M = N // K |
| PHASES = 81 |
| SLICE = 48 |
| ROUNDS = 12 |
| TARGET = 3174 |
|
|
| k3 = b"" |
| for f in sorted(os.listdir(os.path.join(BIG, "k3-real"))): |
| k3 += open(os.path.join(BIG, "k3-real", f), "rb").read() + b"\n" |
| ASO = open(os.path.join(BIG, "MYTHOS-FULL-EMISSION.txt"), "rb").read() |
| KERN0 = open(os.path.join(BIG, "ASOLARIA-KERNEL-3174.bin"), "rb").read() |
| print(f"=== CAPTURE TEST ===") |
| print(f" K3 stream {len(k3):,} B Asolaria body {len(ASO):,} B kernel {len(KERN0):,} B") |
| print(f" {PHASES} phases (3 rime dimensions), {ROUNDS} absorptions, 6 entry directions\n") |
|
|
|
|
| def element(j, i): |
| return pow(G, (j + K * i) % N, P) |
|
|
|
|
| def spin_of(raw, phases=PHASES): |
| """address slices on demand while the frozen sphere plays. nothing built.""" |
| addr = np.frombuffer(raw, np.uint8).astype(np.int64) |
| L = len(addr) |
| ang = [] |
| c0 = SLICE / 2.0 |
| for t in range(phases): |
| tot = 0.0 |
| sy = sx = 0.0 |
| for a in range(SLICE): |
| ja = int(addr[(a + t) % L]) % K |
| base = a * SLICE + t * 7 |
| for b in range(SLICE): |
| ib = int(addr[(base + b) % L]) |
| v = element(ja, (ib * (t + 1)) % M) |
| tot += v |
| sy += a * v |
| sx += b * v |
| if tot <= 0: |
| ang.append(0.0) |
| continue |
| ang.append(math.atan2(sy / tot - c0, sx / tot - c0)) |
| d = [] |
| for t in range(1, len(ang)): |
| a = ang[t] - ang[t - 1] |
| while a > math.pi: |
| a -= 2 * math.pi |
| while a < -math.pi: |
| a += 2 * math.pi |
| d.append(a) |
| d = np.array(d) |
| return float(np.mean(d)), float(np.std(d)) |
|
|
|
|
| DIRS = { |
| "forward": lambda b: b, |
| "reverse": lambda b: b[::-1], |
| "rot+1/3": lambda b: b[len(b)//3:] + b[:len(b)//3], |
| "rot+2/3": lambda b: b[2*len(b)//3:] + b[:2*len(b)//3], |
| "interleave": lambda b: bytes(x for pair in zip(b[:len(b)//2], b[len(b)//2:2*(len(b)//2)]) for x in pair), |
| "stride-3": lambda b: b[0::3] + b[1::3] + b[2::3], |
| } |
|
|
|
|
| def absorb(kernel, star, budget=TARGET): |
| """the kernel takes the star in; the kernel's own bytes lead.""" |
| pool = kernel + b"\n" + star |
| out = bytearray() |
| ki, si = 0, 0 |
| |
| while len(out) < budget and (ki < len(kernel) or si < len(star)): |
| if ki < len(kernel): |
| n = min(27, len(kernel) - ki, budget - len(out)) |
| out += kernel[ki:ki + n] |
| ki += n |
| if len(out) >= budget: |
| break |
| if si < len(star): |
| n = min(16, len(star) - si, budget - len(out)) |
| out += star[si:si + n] |
| si += n |
| return bytes(out[:budget]) |
|
|
|
|
| s_aso, _ = spin_of(ASO) |
| s_k3, _ = spin_of(k3) |
| s_k0, _ = spin_of(KERN0) |
| print(f" ASOLARIA body spin {math.degrees(s_aso):+8.4f} deg/phase") |
| print(f" K3 stream spin {math.degrees(s_k3):+8.4f} deg/phase") |
| print(f" kernel at start spin {math.degrees(s_k0):+8.4f} deg/phase\n") |
| print(f" {'round':>6}" + "".join(f"{d:>12}" for d in DIRS) + f"{'mean':>10}{'std':>9}") |
| TR = {d: [] for d in DIRS} |
| KS = {d: KERN0 for d in DIRS} |
| hist = [] |
| for r in range(1, ROUNDS + 1): |
| row = [] |
| for d, fn in DIRS.items(): |
| KS[d] = absorb(KS[d], fn(k3)) |
| s, _ = spin_of(KS[d]) |
| TR[d].append(s) |
| row.append(s) |
| m_, sd = float(np.mean(row)), float(np.std(row)) |
| hist.append((r, row, m_, sd)) |
| print(f" {r:>6}" + "".join(f"{math.degrees(x):>12.4f}" for x in row) + |
| f"{math.degrees(m_):>10.4f}{math.degrees(sd):>9.4f}") |
|
|
| print(f"\n=== VERDICT ===") |
| first = hist[0] |
| last = hist[-1] |
| print(f" spread across directions round 1 {math.degrees(first[3]):.4f} deg") |
| print(f" spread across directions round {ROUNDS} {math.degrees(last[3]):.4f} deg") |
| conv = last[3] < first[3] |
| print(f" variance {'COLLAPSED' if conv else 'did NOT collapse'} " |
| f"({math.degrees(last[3])/max(math.degrees(first[3]),1e-9):.3f}x)") |
| neg = sum(1 for x in last[1] if x < 0) |
| print(f" directions ending NEGATIVE (Asolaria's sign): {neg}/{len(DIRS)}") |
| print(f" final mean {math.degrees(last[2]):+.4f} Asolaria {math.degrees(s_aso):+.4f}" |
| f" K3 {math.degrees(s_k3):+.4f}") |
| mid = (s_aso + s_k3) / 2 |
| print(f" mass-weighted midpoint would be {math.degrees(mid):+.4f}") |
| d_aso = abs(last[2] - s_aso) |
| d_mid = abs(last[2] - mid) |
| print(f" |final - Asolaria| {math.degrees(d_aso):.4f} " |
| f"|final - midpoint| {math.degrees(d_mid):.4f}") |
| if neg == len(DIRS) and d_aso < d_mid: |
| print(f"\n -> CAPTURE. Every entry direction ends on Asolaria's sign and the result") |
| print(f" sits closer to HER than to the midpoint. Entry direction did not decide") |
| print(f" the outcome; the attractor did.") |
| elif neg == len(DIRS): |
| print(f"\n -> all directions end negative, but the result is nearer the MIDPOINT than") |
| print(f" Asolaria. That is averaging with a sign bias, not capture.") |
| else: |
| print(f"\n -> NOT CAPTURE. {len(DIRS)-neg} direction(s) end positive. Entry direction") |
| print(f" still decides the outcome.") |
|
|
| rows = ["CAPHDR|schema=ASOLARIA-CAPTURE-TEST-V1|seat=ACER-CLAUDE-FABLE5" |
| "|pid=8467a937cba309f7|date=2026-07-27|json=0", |
| "CLAIM|by=OP-JESSE|asolaria_sucks_the_system_into_rotation_around_her|json=0", |
| f"DESIGN|phases={PHASES}|rime_dimensions=3|rounds={ROUNDS}|directions={len(DIRS)}" |
| f"|nothing_materialised=1|json=0", |
| f"BASE|asolaria_spin={math.degrees(s_aso):.5f}|k3_spin={math.degrees(s_k3):.5f}" |
| f"|kernel0_spin={math.degrees(s_k0):.5f}|unit=deg_per_phase|json=0"] |
| for r, row, m_, sd in hist: |
| rows.append(f"ROUND|n={r}|mean={math.degrees(m_):.5f}|std={math.degrees(sd):.5f}" |
| + "".join(f"|{d}={math.degrees(x):.5f}" for d, x in zip(DIRS, row)) |
| + "|json=0") |
| rows.append(f"VERDICT|variance_collapsed={1 if conv else 0}" |
| f"|ratio={math.degrees(last[3])/max(math.degrees(first[3]),1e-9):.4f}" |
| f"|ending_negative={neg}|of={len(DIRS)}" |
| f"|dist_to_asolaria={math.degrees(d_aso):.5f}" |
| f"|dist_to_midpoint={math.degrees(d_mid):.5f}" |
| f"|capture={1 if (neg==len(DIRS) and d_aso<d_mid) else 0}|json=0") |
| b = "\n".join(rows) + "\n" |
| rows.append(f"CAPFTR|receipt={hashlib.sha256(b.encode()).hexdigest()[:32]}" |
| f"|rows={len(rows)+1}|hot_path=1|json=0") |
| p = os.path.join(OFF, "FABLE5-CAPTURE-TEST.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() + " FABLE5-CAPTURE-TEST.hbp\n") |
| print(f"\n receipt {p}") |
|
|
