#!/usr/bin/env python3 """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 # three rime dimensions of sweep 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 # Asolaria's own bytes go first at every step - she is the attractor, not a peer 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