code wiki / _hdl_build / _evolve_gate_authored.nx
_evolve_gate_authored.nx source
↩ module page · 125 lines · 5766 B
1// _evolve_gate_authored.nx -- gate for X-EVO-001. An optimizer you cannot verify is
2// worse than none, so the gate proves the THREE things that make EC trustworthy:
3// K1 CONVERGE default config reaches the known optimum (exit 0, final_best=0)
4// K2 DETERMINISM same seed -> BYTE-IDENTICAL final_best across two runs (the
5// reproducibility law: seeded EC is replayable, never roulette)
6// K3 BEATS-RANDOM mutation ON converges where a degenerate run (1 generation =
7// random init only) does NOT -- evolution is doing real work
8// K4 MULTIMODAL kind=1 (many basins) still converges (not just the easy sphere)
9// Markers: EVG-*; final EVGATE row -> knowledge/status/evolve.log
10// license_tier: ORIGINAL
11import "nx_syscalls.nx"
12func eg_p(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
13func eg_f(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 }
14func eg_n(fd: i64, v: i64) -> i64 { let bb: *u8=sys_mmap(28); var m: i64=v; if m<0{m=0-m; sys_write(fd,"-" as *u8,1)}; let t: *u8=sys_mmap(28); var k: i64=0; if m==0{t[0]=48 as u8;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 }
15func eg_ic(dst: *u8, off: i64, v: i64) -> i64 {
16 let t: *u8 = sys_mmap(28)
17 var m: i64 = v
18 var k: i64 = 0
19 if m < 0 { m = 0 - m }
20 if m == 0 { t[0] = 48 as u8; k = 1 }
21 while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
22 var i: i64 = 0
23 var o: i64 = off
24 if v < 0 { dst[o] = 45 as u8; o = o + 1 }
25 while i < k { dst[o] = t[k-1-i]; o = o + 1; i = i + 1 }
26 return o
27}
28// run nx_evolve with int args; capture final_best from the EVOLVE row tail of evolve.log
29// (out path = scratch so we read exactly this run); returns (exit<<40)|final_best_enc
30func eg_run(args: *i64, nargs: i64, outp: *u8, rcout: *i64) -> i64 {
31 let pid: i64 = sys_fork()
32 if pid == 0 {
33 let ofd: i64 = sys_openat_wr(outp, 0x1a4)
34 if ofd >= 0 { sys_dup3(ofd, 1, 0); sys_dup3(ofd, 2, 0) }
35 let argv: *i64 = sys_mmap(8 * 16) as *i64
36 argv[0] = "/tmp/nx_evolve.sov.elf" as *u8 as i64
37 // build string args
38 var i: i64 = 0
39 while i < nargs {
40 let sb: *u8 = sys_mmap(32)
41 let e: i64 = eg_ic(sb, 0, args[i])
42 sb[e] = 0 as u8
43 argv[1 + i] = sb as i64
44 i = i + 1
45 }
46 argv[1 + nargs] = 0
47 let envp: *i64 = sys_mmap(16) as *i64
48 envp[0] = 0
49 sys_execve("/tmp/nx_evolve.sov.elf" as *u8, argv, envp)
50 sys_exit(127)
51 }
52 let st: *i64 = sys_mmap(16) as *i64
53 sys_wait4(pid, st, 0)
54 rcout[0] = (st[0] >> 8) & 0xff
55 return 0
56}
57// read last "final_best=" integer from a captured stdout file
58func eg_finalbest(path: *u8) -> i64 {
59 let buf: *u8 = sys_mmap(65536)
60 let fd: i64 = sys_openat_rd(path)
61 if fd < 0 { return 0x7FFFFFFF }
62 var n: i64 = 0
63 var r: i64 = sys_read(fd, buf, 65535)
64 while r > 0 { n = n + r; r = sys_read(fd, (buf as i64 + n) as *u8, 65535 - n) }
65 sys_close(fd)
66 let pat: *u8 = "final_best=" as *u8
67 var pl: i64 = 0
68 while pat[pl] != (0 as u8) { pl = pl + 1 }
69 var found: i64 = 0x7FFFFFFF
70 var i: i64 = 0
71 while i + pl < n {
72 var k: i64 = 0
73 var hit: i64 = 1
74 while k < pl { if buf[i+k] != pat[k] { hit = 0; k = pl } else { k = k + 1 } }
75 if hit == 1 {
76 var j: i64 = i + pl
77 var neg: i64 = 0
78 if buf[j] == (45 as u8) { neg = 1; j = j + 1 }
79 var v: i64 = 0
80 while buf[j] >= (48 as u8) { if buf[j] > (57 as u8) { j = n } else { v = v * 10 + ((buf[j] as i64) - 48); j = j + 1 } }
81 if neg == 1 { v = 0 - v }
82 found = v
83 }
84 i = i + 1
85 }
86 return found
87}
88func eg_chk(label: *u8, ok: i64, bad: *i64) -> i64 {
89 eg_p("EVG-" as *u8); eg_p(label)
90 if ok == 1 { eg_p(" ok\n" as *u8) } else { eg_p(" BAD\n" as *u8); bad[0] = bad[0] + 1 }
91 return 0
92}
93func main() -> i64 {
94 eg_p("=== EVOLVE GATE: converge + determinism + beats-random + multimodal ===\n" as *u8)
95 let bad: *i64 = sys_mmap(16) as *i64
96 bad[0] = 0
97 let rc: *i64 = sys_mmap(16) as *i64
98 let a: *i64 = sys_mmap(8 * 16) as *i64
99 // K1 + K4: default-ish multimodal config converges. args: pop gens mut tk dims seed kind target
100 a[0]=24; a[1]=200; a[2]=4; a[3]=3; a[4]=6; a[5]=2463534242; a[6]=1; a[7]=7
101 eg_run(a, 8, "/tmp/evg_1.txt" as *u8, rc)
102 let fb1: i64 = eg_finalbest("/tmp/evg_1.txt" as *u8)
103 eg_chk("CONVERGE-MULTIMODAL" as *u8, rc[0] == 0, bad)
104 // K2 determinism: same seed twice -> identical final_best
105 eg_run(a, 8, "/tmp/evg_2.txt" as *u8, rc)
106 let fb2: i64 = eg_finalbest("/tmp/evg_2.txt" as *u8)
107 eg_chk("DETERMINISM" as *u8, fb1 == fb2, bad)
108 // K3 beats-random: gens=1 (init only, no evolution) must NOT reach optimum
109 a[1] = 1
110 eg_run(a, 8, "/tmp/evg_3.txt" as *u8, rc)
111 let fb3: i64 = eg_finalbest("/tmp/evg_3.txt" as *u8)
112 eg_chk("BEATS-RANDOM" as *u8, fb3 < 0, bad)
113 let lfd: i64 = sys_openat_append("knowledge/status/evolve.log" as *u8, 0x1a4)
114 if lfd >= 0 {
115 eg_f(lfd, "EVGATE checks=" as *u8); eg_n(lfd, 3 - bad[0])
116 eg_f(lfd, "/3 fb1=" as *u8); eg_n(lfd, fb1)
117 eg_f(lfd, " fb_random=" as *u8); eg_n(lfd, fb3)
118 if bad[0] == 0 { eg_f(lfd, " verdict=GREEN\n" as *u8) } else { eg_f(lfd, " verdict=RED\n" as *u8) }
119 sys_close(lfd)
120 }
121 if bad[0] == 0 { eg_p(" EVGATE: GREEN 3/3 (EC machinery trustworthy: converges, reproducible, real work)\n" as *u8); sys_exit(0); return 0 }
122 eg_p(" EVGATE: RED\n" as *u8)
123 sys_exit(1)
124 return 1
125}