code wiki / _hdl_build / _ale_aggregate_gate.nx
_ale_aggregate_gate.nx source
↩ module page · 322 lines · 12444 B
1// _ale_aggregate_gate.nx -- the ALE-R1c gate: sovereign AGGREGATE fold (ALE's headline mean).
2// Diff-lane / no-mocks: runs the REAL sovereign organ nx_ale_aggregate.elf (built by
3// nx_cc_sovereign->nxasm_x86_main, NO gcc) over REAL fixtures and asserts ALL of:
4// (1) MEAN-EXACT -- scores_set (1000,500,0 over 3 tasks) folds to exactly 500 = (1500)/3
5// (2) BOUNDED -- every emitted aggregate lies in [0,1000]; corrupt_set's out-of-range
6// per-task value (2000) is clamped on read -> 750, never escapes [0,1]
7// (3) BREAKDOWN -- a task|<id>|<milli> line is emitted for every task (N==3 here) and
8// re-folding those EMITTED lines yields the IDENTICAL mean (500)
9// (4) DETERMINISTIC -- two consecutive runs on the SAME fixture emit byte-identical output
10// (5) DEGENERATE -- empty_set (N==0) folds to exactly 0 (no divide-by-zero)
11// (6) TAMPER -- a BROKEN aggregator (drops a task from the denominator + skips the
12// clamp) emits an out-of-[0,1000] / wrong mean on overshoot_set (1050
13// vs honest 700) and is REJECTED; the real organ folds the same fixture
14// to a bounded 700 -> negative control bites
15// The aggregate + breakdown are read back from a scratch FILE the organ writes ("agg|<n>\n"
16// then "task|<id>|<milli>\n" x N), dodging the 0..255 process-exit-code ceiling. The organ's
17// purity (no clock/rand) IS the oracle. Evidence -> knowledge/status/ale_aggregate.log
18// (ALEAGGGATE row; the queue row's ||MARK= reads it). license_tier: ORIGINAL
19import "nx_syscalls.nx"
20
21func g_p(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 }
22func g_fp(fd: i64, s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(fd, s, n); return 0 }
23func g_fn(fd: i64, v: i64) -> i64 { let bb: *u8 = sys_mmap(28); var m: i64 = v; if m < 0 { m = 0 - m }; let t: *u8 = sys_mmap(28); var k: i64 = 0; if m == 0 { t[0] = 48; k = 1 }; while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }; var i: i64 = 0; while i < k { bb[i] = t[k - 1 - i]; i = i + 1 }; sys_write(fd, bb, k); return 0 }
24
25// read whole file into buf (cap), return byte count (0 on open-fail / empty)
26func g_read(path: *u8, buf: *u8, cap: i64) -> i64 {
27 let fd: i64 = sys_openat_rd(path)
28 if fd < 0 { return 0 }
29 var n: i64 = 0
30 var go: i64 = 1
31 while go == 1 {
32 let r: i64 = sys_read(fd, (buf as i64 + n) as *u8, cap - 1 - n)
33 if r <= 0 { go = 0 } else { n = n + r }
34 if n >= cap - 1 { go = 0 }
35 }
36 sys_close(fd)
37 return n
38}
39
40func g_is_bol(buf: *u8, pos: i64) -> i64 {
41 if pos == 0 { return 1 }
42 if buf[pos - 1] == (10 as u8) { return 1 }
43 return 0
44}
45
46func g_line_end(buf: *u8, n: i64, start: i64) -> i64 {
47 var e: i64 = start
48 while e < n {
49 if buf[e] == (10 as u8) { return e }
50 e = e + 1
51 }
52 return n
53}
54
55func g_pfx_eq(pfx: *u8, plen: i64, buf: *u8, pos: i64) -> i64 {
56 var k: i64 = 0
57 while k < plen {
58 if pfx[k] != buf[pos + k] { return 0 }
59 k = k + 1
60 }
61 return 1
62}
63
64func g_len(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
65
66// index just AFTER the 2nd '|' in buf[start..end); -1 if absent
67func g_milli_start(buf: *u8, start: i64, end: i64) -> i64 {
68 var bars: i64 = 0
69 var j: i64 = start
70 while j < end {
71 if buf[j] == (124 as u8) { bars = bars + 1; if bars == 2 { return j + 1 } }
72 j = j + 1
73 }
74 return 0 - 1
75}
76
77func g_parse_int(buf: *u8, from: i64, end: i64) -> i64 {
78 var seen: i64 = 0
79 var v: i64 = 0
80 var j: i64 = from
81 while j < end {
82 let c: i64 = buf[j] as i64
83 if c >= 48 { if c <= 57 { v = (v * 10) + (c - 48); seen = 1 } else { j = end } } else { if seen == 1 { j = end } }
84 j = j + 1
85 }
86 if seen == 0 { return 0 - 1 }
87 return v
88}
89
90// parse the value off the "agg|<v>" line at the START of an output buffer; -1 if absent.
91func g_agg_of(buf: *u8, n: i64) -> i64 {
92 let pfx: *u8 = "agg|" as *u8
93 let pl: i64 = g_len(pfx)
94 if n < pl { return 0 - 1 }
95 if g_pfx_eq(pfx, pl, buf, 0) == 0 { return 0 - 1 }
96 let le: i64 = g_line_end(buf, n, 0)
97 return g_parse_int(buf, pl, le)
98}
99
100// count "task|" breakdown lines in an output buffer
101func g_task_count(buf: *u8, n: i64) -> i64 {
102 let pfx: *u8 = "task|" as *u8
103 let pl: i64 = g_len(pfx)
104 var cnt: i64 = 0
105 var i: i64 = 0
106 while i < n {
107 if g_is_bol(buf, i) == 1 {
108 if i + pl <= n {
109 if g_pfx_eq(pfx, pl, buf, i) == 1 { cnt = cnt + 1 }
110 }
111 }
112 i = i + 1
113 }
114 return cnt
115}
116
117// RE-FOLD the "task|<id>|<milli>" breakdown lines of an output buffer back into a clamped
118// mean -- the gate's own INDEPENDENT fold of the organ's emitted breakdown. -1 if zero tasks.
119func g_refold(buf: *u8, n: i64) -> i64 {
120 let pfx: *u8 = "task|" as *u8
121 let pl: i64 = g_len(pfx)
122 var total: i64 = 0
123 var sum: i64 = 0
124 var i: i64 = 0
125 while i < n {
126 if g_is_bol(buf, i) == 1 {
127 var istask: i64 = 0
128 if i + pl <= n {
129 if g_pfx_eq(pfx, pl, buf, i) == 1 { istask = 1 }
130 }
131 if istask == 1 {
132 let le: i64 = g_line_end(buf, n, i)
133 let ms: i64 = g_milli_start(buf, i, le)
134 if ms >= 0 {
135 let raw: i64 = g_parse_int(buf, ms, le)
136 if raw >= 0 {
137 var cl: i64 = raw
138 if cl < 0 { cl = 0 }
139 if cl > 1000 { cl = 1000 }
140 total = total + 1
141 sum = sum + cl
142 }
143 }
144 i = le
145 }
146 }
147 i = i + 1
148 }
149 if total == 0 { return 0 - 1 }
150 var mean: i64 = sum / total
151 if mean < 0 { mean = 0 }
152 if mean > 1000 { mean = 1000 }
153 return mean
154}
155
156// byte-for-byte equality of two buffers; 1/0
157func g_buf_eq(a: *u8, na: i64, b: *u8, nb: i64) -> i64 {
158 if na != nb { return 0 }
159 var i: i64 = 0
160 while i < na {
161 if a[i] != b[i] { return 0 }
162 i = i + 1
163 }
164 return 1
165}
166
167// run an aggregate ELF: execve <elf> <fixture> <out>; child writes agg+breakdown to <out>.
168// returns 0 on spawn/wait OK (the caller reads <out> back), -1 on failure.
169func g_run(elf: *u8, fix: *u8, out: *u8) -> i64 {
170 let pid: i64 = sys_fork()
171 if pid == 0 {
172 let dn: i64 = sys_openat_wr("/dev/null" as *u8, 0x1a4)
173 if dn >= 0 { sys_dup3(dn, 1, 0); sys_dup3(dn, 2, 0) }
174 let argv: *i64 = sys_mmap(48) as *i64
175 argv[0] = elf as i64
176 argv[1] = fix as i64
177 argv[2] = out as i64
178 argv[3] = 0
179 let envp: *i64 = sys_mmap(16) as *i64
180 envp[0] = 0
181 sys_execve(elf, argv, envp)
182 sys_exit(127)
183 }
184 let st: *i64 = sys_mmap(16) as *i64
185 sys_wait4(pid, st, 0)
186 return 0
187}
188
189func main() -> i64 {
190 let elf: *u8 = "_offc/nx_ale_aggregate.elf" as *u8
191 let tamper: *u8 = "_offc/nx_ale_aggregate_tamper_stub.elf" as *u8
192 let f_scores: *u8 = "knowledge/specs/ale_aggregate_examples/scores_set.txt" as *u8
193 let f_empty: *u8 = "knowledge/specs/ale_aggregate_examples/empty_set.txt" as *u8
194 let f_over: *u8 = "knowledge/specs/ale_aggregate_examples/overshoot_set.txt" as *u8
195 let f_corrupt: *u8 = "knowledge/specs/ale_aggregate_examples/corrupt_set.txt" as *u8
196 let o1: *u8 = "/tmp/_aleagg_o1" as *u8
197 let o2: *u8 = "/tmp/_aleagg_o2" as *u8
198 let oe: *u8 = "/tmp/_aleagg_oe" as *u8
199 let oc: *u8 = "/tmp/_aleagg_oc" as *u8
200 let ov: *u8 = "/tmp/_aleagg_ov" as *u8
201 let ot: *u8 = "/tmp/_aleagg_ot" as *u8
202 g_p("=== ALE-aggregate gate (ALE-R1c: sovereign headline-mean fold) ===\n" as *u8)
203
204 let b1: *u8 = sys_mmap(65536)
205 let b2: *u8 = sys_mmap(65536)
206 let be: *u8 = sys_mmap(65536)
207 let bc: *u8 = sys_mmap(65536)
208 let bv: *u8 = sys_mmap(65536)
209 let bt: *u8 = sys_mmap(65536)
210
211 // (1) MEAN-EXACT: scores_set -> agg 500 = (1000+500+0)/3
212 g_run(elf, f_scores, o1)
213 let n1: i64 = g_read(o1, b1, 65536)
214 let agg1: i64 = g_agg_of(b1, n1)
215 var c1: i64 = 0
216 if agg1 == 500 { c1 = 1 }
217
218 // (3) BREAKDOWN: N==3 task| lines emitted AND they re-fold (gate's own independent fold)
219 // back to the IDENTICAL mean (500).
220 let tc1: i64 = g_task_count(b1, n1)
221 let rf1: i64 = g_refold(b1, n1)
222 var c3: i64 = 0
223 if tc1 == 3 { if rf1 == agg1 { if rf1 == 500 { c3 = 1 } } }
224
225 // (4) DETERMINISTIC: a second run on the same fixture is BYTE-IDENTICAL
226 g_run(elf, f_scores, o2)
227 let n2: i64 = g_read(o2, b2, 65536)
228 var c4: i64 = 0
229 if g_buf_eq(b1, n1, b2, n2) == 1 { if n1 > 0 { c4 = 1 } }
230
231 // (5) DEGENERATE: empty_set (N==0) -> agg 0, no divide-by-zero
232 g_run(elf, f_empty, oe)
233 let ne: i64 = g_read(oe, be, 65536)
234 let agge: i64 = g_agg_of(be, ne)
235 var c5: i64 = 0
236 if agge == 0 { c5 = 1 }
237
238 // (2) BOUNDED: corrupt_set's out-of-range per-task (2000) is clamped on read -> (1000+500)/2
239 // = 750, in [0,1000]; AND the honest overshoot fold = (1000+1000+100)/3 = 700, in range.
240 g_run(elf, f_corrupt, oc)
241 let nc: i64 = g_read(oc, bc, 65536)
242 let aggc: i64 = g_agg_of(bc, nc)
243 g_run(elf, f_over, ov)
244 let nv: i64 = g_read(ov, bv, 65536)
245 let aggv: i64 = g_agg_of(bv, nv)
246 var c2: i64 = 1
247 if agg1 < 0 { c2 = 0 }
248 if agg1 > 1000 { c2 = 0 }
249 if agge < 0 { c2 = 0 }
250 if agge > 1000 { c2 = 0 }
251 if aggc < 0 { c2 = 0 }
252 if aggc > 1000 { c2 = 0 }
253 if aggv < 0 { c2 = 0 }
254 if aggv > 1000 { c2 = 0 }
255 // the clamp-on-read must BITE: corrupt -> 750 (not 1250), overshoot -> 700
256 var c2b: i64 = 0
257 if aggc == 750 { if aggv == 700 { c2b = 1 } }
258
259 // (6) TAMPER: the BROKEN aggregator (drops a task + skips clamp) emits an out-of-range /
260 // wrong mean on overshoot_set (1050) vs the honest 700; REJECTED. Negative control bites
261 // iff the tamper agg is out-of-[0,1000] OR != the honest mean.
262 g_run(tamper, f_over, ot)
263 let nt: i64 = g_read(ot, bt, 65536)
264 let aggt: i64 = g_agg_of(bt, nt)
265 var tamper_rejected: i64 = 0
266 if aggt > 1000 { tamper_rejected = 1 }
267 if aggt < 0 { tamper_rejected = 1 }
268 if aggt != aggv { tamper_rejected = 1 }
269
270 g_p(" mean_exact=" as *u8); g_fn(1, agg1)
271 g_p(" tasks=" as *u8); g_fn(1, tc1)
272 g_p(" refold=" as *u8); g_fn(1, rf1)
273 g_p(" degenerate=" as *u8); g_fn(1, agge)
274 g_p(" corrupt=" as *u8); g_fn(1, aggc)
275 g_p(" overshoot=" as *u8); g_fn(1, aggv)
276 g_p(" tamper=" as *u8); g_fn(1, aggt)
277 g_p("\n" as *u8)
278 g_p(" c1_mean=" as *u8); g_fn(1, c1)
279 g_p(" c2_bounded=" as *u8); g_fn(1, c2)
280 g_p(" c2b_clampbites=" as *u8); g_fn(1, c2b)
281 g_p(" c3_breakdown=" as *u8); g_fn(1, c3)
282 g_p(" c4_determ=" as *u8); g_fn(1, c4)
283 g_p(" c5_degenerate=" as *u8); g_fn(1, c5)
284 g_p(" tamper_rejected=" as *u8); g_fn(1, tamper_rejected)
285 g_p("\n" as *u8)
286
287 var allok: i64 = 1
288 if c1 == 0 { allok = 0 }
289 if c2 == 0 { allok = 0 }
290 if c2b == 0 { allok = 0 }
291 if c3 == 0 { allok = 0 }
292 if c4 == 0 { allok = 0 }
293 if c5 == 0 { allok = 0 }
294 if tamper_rejected == 0 { allok = 0 }
295
296 let lfd: i64 = sys_openat_append("knowledge/status/ale_aggregate.log" as *u8, 0x1a4)
297 if allok == 1 {
298 g_p("ALEAGGGATE verdict=GREEN (mean=500 bounded clamp-bites breakdown-refold det degenerate=0; drop-task tamper REJECTED)\n" as *u8)
299 if lfd >= 0 {
300 g_fp(lfd, "ALEAGGGATE verdict=GREEN mean=500 bounded=1 clampbites=1 breakdown=1 det=1 degenerate=0 tamper_rejected=1 rung=ALE-R1c epoch=" as *u8)
301 g_fn(lfd, sys_now_realtime_sec())
302 g_fp(lfd, "\n" as *u8)
303 sys_close(lfd)
304 }
305 sys_exit(0)
306 return 0
307 }
308 g_p("ALEAGGGATE verdict=RED (a check did not fire)\n" as *u8)
309 if lfd >= 0 {
310 g_fp(lfd, "ALEAGGGATE verdict=RED c1=" as *u8); g_fn(lfd, c1)
311 g_fp(lfd, " c2=" as *u8); g_fn(lfd, c2)
312 g_fp(lfd, " c2b=" as *u8); g_fn(lfd, c2b)
313 g_fp(lfd, " c3=" as *u8); g_fn(lfd, c3)
314 g_fp(lfd, " c4=" as *u8); g_fn(lfd, c4)
315 g_fp(lfd, " c5=" as *u8); g_fn(lfd, c5)
316 g_fp(lfd, " tamper_rejected=" as *u8); g_fn(lfd, tamper_rejected)
317 g_fp(lfd, "\n" as *u8)
318 sys_close(lfd)
319 }
320 sys_exit(1)
321 return 1
322}