Files
LithosAnanke/v4/system/inference.c
T
Claude 6d954ac279 feat(v4): Phase 7 Task 3 -- the inference engine and Loop #7 in each node's heartbeat cycle (#189)
v4/system/inference.c: v3's inference_engine.c and its Q48.16 arithmetic ported to the bit, no C library --
the variance, the window width (Levene), the decay slope (log-linear regression), the run with its 5%
early exit. v4/tests/test_inference.c links v3's own and compares them: POST's fixed cases, 20000 random
multiply/log pairs, 400 random trajectories (make -C v4 inference; in make -C v4 test). In each node's
cycle every 1000 ticks (HEARTBEAT_INFERENCE_FREQUENCY), once the window is warm: the trajectory from the
window's words' heat, the width and slope applied unless it exits early, then Loop #7 -- the heartrate
slower when stable, faster when not, within 1/4..4x; Hera's re-arms the kernel's heartbeat
(heartbeat_set_adaptive_period_ns), as v3's Hera. L8 reads its outcome. Test first: test_mesh_boot.c 72
checks, 80 on. amd64 PASS, 163 s. Not pushed (held to the end of Phase 7).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017RzZgrf7V7Zk2iczBXDRbm
2026-11-13 23:59:18 +00:00

194 lines
6.9 KiB
C

/* SPDX-License-Identifier: LicenseRef-Starship-1.0
* Copyright (c) 2023-2026 Robert A. James
*/
/* inference.c -- the inference engine for a node's heartbeat. See v4/inference.h (#189, Phase 7). */
#include "v4/inference.h"
#define WINDOW 4096u /* v3's ROLLING_WINDOW_SIZE */
#define WINDOW_MIN 256u /* v3's ADAPTIVE_MIN_WINDOW_SIZE */
#define MAX_CHUNKS (WINDOW / WINDOW_MIN)
/* ---- Q48.16, as v3's (v3/include/q48_16.h, v3/src/word_source/q48_16_words.c) ---- */
static v4_q48 from_u64(uint64_t u) { return u << 16; }
static uint64_t to_u64(v4_q48 q) /* v3: (int64_t)q >> 16, arithmetic */
{
return (q & 0x8000000000000000ULL) ? ~((~q) >> 16) : q >> 16;
}
/* the high 128-bit product, >> 16: v3's __uint128_t path, written out (64 x 64 in four parts) */
v4_q48 v4_q48_mul(v4_q48 a, v4_q48 b)
{
uint64_t a_hi = a >> 32, a_lo = a & 0xFFFFFFFFULL, b_hi = b >> 32, b_lo = b & 0xFFFFFFFFULL;
uint64_t p_ll = a_lo * b_lo, p_lh = a_lo * b_hi, p_hl = a_hi * b_lo, p_hh = a_hi * b_hi;
uint64_t carry = 0, mid = p_lh + p_hl, hi, lo;
if (mid < p_lh) carry++;
hi = p_hh + (mid >> 32) + (carry << 32);
lo = p_ll + ((mid & 0xFFFFFFFFULL) << 32);
if (lo < p_ll) hi++;
return (hi << 48) | (lo >> 16);
}
v4_q48 v4_q48_div(v4_q48 a, v4_q48 b)
{
if (b == 0) return 0;
if (a > 0x0000FFFFFFFFFFFFULL) return 0xFFFFFFFFFFFFFFFFULL;
return (a << 16) / b;
}
v4_q48 v4_q48_exp(v4_q48 q)
{
int64_t qs = (int64_t)q;
int negative, n;
v4_q48 x, result, term;
if (q == 0) return 65536;
if (qs >= 1048576) return 0xFFFFFFFFFFFFFFFFULL;
if (qs <= -1048576) return 0;
negative = qs < 0;
x = negative ? (v4_q48)(-qs) : q;
result = 65536;
term = x;
result += term;
for (n = 2; n <= 10; n++) {
term = v4_q48_mul(term, x);
term = v4_q48_div(term, from_u64((uint64_t)n));
result += term;
if (term < 50) break;
}
if (negative) result = v4_q48_div(65536, result);
return result;
}
v4_q48 v4_q48_log(uint64_t x)
{
const v4_q48 ln2 = 45426;
int k = 0, iter;
uint64_t m = x;
v4_q48 y, result;
if (x == 0 || x == 65536) return 0;
if (m >= 131072) { while (m >= 131072) { m >>= 1; k++; } }
else if (m < 65536) { while (m < 65536) { m <<= 1; k--; } }
y = m > 65536 ? m - 65536 : 0;
for (iter = 0; iter < 6; iter++) {
v4_q48 e = v4_q48_exp(y), corr;
int64_t d;
if (e == 0) break;
d = (int64_t)m - (int64_t)e;
if (d > 0) { corr = v4_q48_div((v4_q48)d, e); y = y + corr; }
else if (d < 0) { corr = v4_q48_div((v4_q48)(-d), e); y = y > corr ? y - corr : 0; }
if (d < 100 && d > -100) break;
}
result = y;
if (k > 0) result = result + v4_q48_mul(from_u64((uint64_t)k), ln2);
else if (k < 0) result = result - v4_q48_mul(from_u64((uint64_t)-k), ln2);
return result;
}
/* ---- the engine (v3/src/inference_engine.c) ---- */
v4_q48 v4_inference_variance(const uint64_t *heat, uint64_t n)
{
uint64_t sum = 0, sq = 0, i;
v4_q48 mean;
if (n == 0) return 0;
for (i = 0; i < n; i++) sum += heat[i];
mean = v4_q48_div(from_u64(sum), from_u64(n));
for (i = 0; i < n; i++) {
v4_q48 h = from_u64(heat[i]), d = h > mean ? h - mean : mean - h;
sq += to_u64(v4_q48_mul(d, d));
}
return v4_q48_div(from_u64(sq), from_u64(n));
}
static v4_q48 median(const v4_q48 *data, uint32_t n) /* v3's: a sorted copy's middle */
{
v4_q48 s[MAX_CHUNKS];
uint32_t i, j;
if (n == 0) return 0;
if (n == 1) return data[0];
for (i = 0; i < n; i++) s[i] = data[i];
for (i = 0; i < n - 1; i++)
for (j = 0; j < n - i - 1; j++)
if (s[j] > s[j + 1]) { v4_q48 t = s[j]; s[j] = s[j + 1]; s[j + 1] = t; }
return s[n / 2];
}
static v4_q48 mean_q48(const v4_q48 *data, uint32_t n) /* v3's: of the integer parts */
{
uint64_t sum = 0;
uint32_t i;
if (n == 0) return 0;
for (i = 0; i < n; i++) sum += data[i] >> 16;
return from_u64(sum / n);
}
static v4_q48 levene(const v4_q48 *vars, uint32_t k, uint32_t size)
{
v4_q48 med, z[MAX_CHUNKS], zbar, ssd = 0, num, den;
uint32_t i;
if (k < 2) return 0;
med = median(vars, k);
for (i = 0; i < k; i++) z[i] = vars[i] > med ? vars[i] - med : med - vars[i];
zbar = mean_q48(z, k);
for (i = 0; i < k; i++) { v4_q48 d = z[i] > zbar ? z[i] - zbar : zbar - z[i]; ssd = ssd + v4_q48_mul(d, d); }
num = v4_q48_mul(from_u64(k - 1u), v4_q48_mul(from_u64(size), ssd));
den = v4_q48_mul(from_u64(k), v4_inference_variance(z, k)); /* v3 takes the z's variance as raw values */
return den > 0 ? v4_q48_div(num, den) : 0;
}
uint32_t v4_inference_window_width(const uint64_t *heat, uint64_t n)
{
uint32_t size, max = n < WINDOW ? (uint32_t)n : WINDOW;
const v4_q48 critical = 425984; /* v3's q48_from_double(6.5) */
if (n == 0) return WINDOW / 2;
for (size = WINDOW_MIN; size <= max; size += 64) {
uint32_t k = (uint32_t)(n / size), i;
v4_q48 vars[MAX_CHUNKS];
if (k < 3) continue;
if (k > MAX_CHUNKS) k = MAX_CHUNKS; /* n <= 4096, so never more */
for (i = 0; i < k; i++) vars[i] = v4_inference_variance(&heat[(uint64_t)i * size], size);
if (levene(vars, k, size) <= critical) return size;
}
return max;
}
uint64_t v4_inference_decay_slope(const uint64_t *heat, uint64_t n)
{
uint64_t sum_t, sum_t_sq, t, num, den;
v4_q48 sum_log = 0, sum_t_log = 0;
int64_t a, b, ns;
if (n < 2) return 0;
sum_t = (n * (n - 1)) / 2;
sum_t_sq = (n * (n - 1) * (2 * n - 1)) / 6;
for (t = 0; t < n; t++) {
v4_q48 l;
if (heat[t] == 0) continue;
l = v4_q48_log(heat[t]);
sum_log = sum_log + l;
sum_t_log = sum_t_log + v4_q48_mul(from_u64(t), l);
}
a = (int64_t)v4_q48_mul(from_u64(n), sum_t_log);
b = (int64_t)v4_q48_mul(from_u64(sum_t), sum_log);
ns = a - b;
num = ns < 0 ? (uint64_t)(-ns) : (uint64_t)ns;
den = n * sum_t_sq - sum_t * sum_t;
if (den == 0) den = 1;
return num / den;
}
void v4_inference_run(const uint64_t *traj, uint64_t n, int l5, int l6, v4_inference_out *out)
{
v4_q48 var;
if (!traj || n < 2) { out->early_exited = 1; return; }
var = v4_inference_variance(traj, n);
if (out->window_variance_q48 != 0) { /* v3's has_variance_stabilized: within 5% */
v4_q48 last = out->window_variance_q48, d = var > last ? var - last : last - var;
if (v4_q48_div(d, last) <= 3276) { out->early_exited = 1; return; }
}
if (l5) out->adaptive_window_width = v4_inference_window_width(traj, n);
if (l6) out->adaptive_decay_slope = v4_inference_decay_slope(traj, n);
out->window_variance_q48 = var;
out->slope_fit_quality_q48 = 52429; /* v3's: 0.8, a placeholder it says it is */
out->early_exited = 0;
}