code wiki / _hdl_build / nx_math_census.nx
nx_math_census.nx source
↩ module page · 199 lines · 9120 B
1// nx_math_census.nx -- the HONEST math coverage census vs the FULL incumbent inventory
2// (knowledge/registry/math_incumbent_ref.tsv: DLMF 36 ch + GAMS A-L + Wolfram pillars).
3// Replaces the 17-row scorecard's misleading "overall=764" (a narrow self-selected slice)
4// with a TRUE reach permil measured across everything Wolfram/NIST call out. No-wave law:
5// PRESENT iff the row's <gate> marker is verdict=GREEN in math_engine.log; gate "-" =
6// ABSENT by construction (we have no gate for it). Weighted reach per category + overall;
7// EXCEED reads GREEN only at reach=1000 (NIST-EXCEED), else BEHIND with the honest number
8// and the ABSENT backlog enumerated. Self-validating (pos/neg controls before the real run).
9//
10// Emits knowledge/registry/math_census.tsv + a MATHCENSUS line (+ ABSENT list) ->
11// knowledge/status/math_census.log.
12//
13// module: nishi-core.math.census
14// depends: nishi-core.sys.syscalls
15// capability: MATH_COVERAGE_CENSUS_VS_INCUMBENTS
16// license_tier: ORIGINAL
17import "nx_syscalls.nx"
18const MC_MAGIC_524288: i64 = 524288
19const MC_MAGIC_131072: i64 = 131072
20const MC_MAGIC_8192: i64 = 8192
21const MC_MAGIC_7900: i64 = 7900
22
23const MC_REF: *u8 = "knowledge/registry/math_incumbent_ref.tsv"
24const MC_LOG: *u8 = "knowledge/status/math_engine.log"
25const MC_MAP: *u8 = "knowledge/registry/math_census.tsv"
26const MC_OUT: *u8 = "knowledge/status/math_census.log"
27
28func mc_w(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 }
29func mc_wn(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;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 }
30func mc_len(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} return n }
31
32func mc_read(path: *u8, buf: *u8, cap: i64) -> i64 {
33 let fd: i64 = sys_openat_rd(path)
34 if fd < 0 { return 0 }
35 var n: i64 = 0
36 var r: i64 = sys_read(fd, buf, cap - 1)
37 while r > 0 { n = n + r; if n >= cap - 1 { r = 0 } else { r = sys_read(fd, buf + n, cap - 1 - n) } }
38 sys_close(fd)
39 return n
40}
41
42// line-anchored: a line STARTING with tag (len tl) that contains verdict=GREEN -> 1.
43func mc_tag_green(buf: *u8, n: i64, tag: *u8, tl: i64) -> i64 {
44 if tl == 0 { return 0 }
45 var i: i64 = 0
46 while i + tl <= n {
47 var hit: i64 = 1
48 if i > 0 { if buf[i - 1] != (10 as u8) { hit = 0 } }
49 var j: i64 = 0
50 while j < tl {
51 if hit == 0 { j = tl } else { if buf[i + j] != tag[j] { hit = 0; j = tl } else { j = j + 1 } }
52 }
53 if hit == 1 {
54 let g: *u8 = "verdict=GREEN" as *u8
55 var p: i64 = i
56 while p < n {
57 if buf[p] == (10 as u8) { p = n } else {
58 var q: i64 = 0
59 var gh: i64 = 1
60 while q < 13 { if p + q >= n { gh = 0; q = 13 } else { if buf[p + q] != g[q] { gh = 0; q = 13 } else { q = q + 1 } } }
61 if gh == 1 { return 1 }
62 p = p + 1
63 }
64 }
65 }
66 i = i + 1
67 }
68 return 0
69}
70
71// copy tab-field f of line [ls,le) into dst; returns length.
72func mc_field(buf: *u8, ls: i64, le: i64, f: i64, dst: *u8, cap: i64) -> i64 {
73 var col: i64 = 0
74 var p: i64 = ls
75 var k: i64 = 0
76 while p < le {
77 if buf[p] == (9 as u8) { if col == f { dst[k] = 0 as u8; return k } col = col + 1; if col == f { k = 0 } }
78 else { if col == f { if k < cap - 1 { dst[k] = buf[p]; k = k + 1 } } }
79 p = p + 1
80 }
81 dst[k] = 0 as u8
82 return k
83}
84
85// category index: 0 DLMF, 1 GAMS, 2 WOLFRAM, 3 = overall accumulator
86func mc_cat(s: *u8) -> i64 {
87 if s[0] == (68 as u8) { return 0 } // D(LMF)
88 if s[0] == (71 as u8) { return 1 } // G(AMS)
89 if s[0] == (87 as u8) { return 2 } // W(OLFRAM)
90 return 2
91}
92
93func mc_cpy(dst: *u8, s: *u8) -> i64 { var i: i64=0; while s[i]!=(0 as u8){dst[i]=s[i]; i=i+1} dst[i]=0 as u8; return i }
94func mc_selftest() -> i64 {
95 let b: *u8 = sys_mmap(128)
96 let n: i64 = mc_cpy(b, "GAMMAGATE epoch=1 max_ulp=7 verdict=GREEN\n" as *u8)
97 if mc_tag_green(b, n, "GAMMAGATE" as *u8, 9) != 1 { return 1 }
98 if mc_tag_green(b, n, "BESSELJGATE" as *u8, 11) != 0 { return 2 } // absent
99 if mc_tag_green(b, n, "AMMAGATE" as *u8, 8) != 0 { return 3 } // not line-anchored
100 return 0
101}
102
103func main() -> i64 {
104 let st: i64 = mc_selftest()
105 if st != 0 { mc_w(1, "MATHCENSUS verdict=RED reason=selftest code=" as *u8); mc_wn(1, st); mc_w(1, "\n" as *u8); sys_exit(10); return 10 }
106
107 let lbuf: *u8 = sys_mmap(MC_MAGIC_524288)
108 let ln: i64 = mc_read(MC_LOG, lbuf, MC_MAGIC_524288)
109 let rbuf: *u8 = sys_mmap(MC_MAGIC_131072)
110 let rn: i64 = mc_read(MC_REF, rbuf, MC_MAGIC_131072)
111 if rn <= 0 { mc_w(1, "MATHCENSUS verdict=RED reason=no-ref\n" as *u8); sys_exit(11); return 11 }
112
113 let pw: *i64 = sys_mmap(8 * 4) as *i64 // present weight per cat (+overall@3)
114 let tw: *i64 = sys_mmap(8 * 4) as *i64
115 let pc: *i64 = sys_mmap(8 * 4) as *i64 // present count
116 let tc: *i64 = sys_mmap(8 * 4) as *i64
117 let cat: *u8 = sys_mmap(64)
118 let gate: *u8 = sys_mmap(128)
119 let wts: *u8 = sys_mmap(32)
120 let feat: *u8 = sys_mmap(256)
121 let idf: *u8 = sys_mmap(64)
122
123 let mfd: i64 = sys_openat_wr(MC_MAP, 0x1a4)
124 if mfd >= 0 { mc_w(mfd, "# AUTHORED BY nx_math_census -- coverage vs math_incumbent_ref.tsv (DLMF+GAMS+Wolfram). PRESENT iff gate verdict=GREEN in math_engine.log; gate '-' = ABSENT.\n# columns: id\tcategory\tfeature\tstatus\tweight\n" as *u8) }
125
126 // collect ABSENT ids into a buffer for the backlog line
127 let absbuf: *u8 = sys_mmap(MC_MAGIC_8192)
128 var abo: i64 = 0
129
130 var ls: i64 = 0
131 var i: i64 = 0
132 while i <= rn {
133 var eol: i64 = 0
134 if i == rn { eol = 1 } else { if rbuf[i] == (10 as u8) { eol = 1 } }
135 if eol == 1 {
136 if i > ls { if rbuf[ls] != (35 as u8) { // skip '#'
137 mc_field(rbuf, ls, i, 0, idf, 64)
138 if mc_len(idf) > 0 {
139 mc_field(rbuf, ls, i, 1, cat, 64)
140 mc_field(rbuf, ls, i, 2, feat, 256)
141 mc_field(rbuf, ls, i, 3, gate, 128)
142 let wl: i64 = mc_field(rbuf, ls, i, 4, wts, 32)
143 var wv: i64 = 0
144 var z: i64 = 0
145 while z < wl { if wts[z] >= (48 as u8) { if wts[z] <= (57 as u8) { wv = wv * 10 + (wts[z] - 48) } } z = z + 1 }
146 if wv == 0 { wv = 1 }
147 let ci: i64 = mc_cat(cat)
148 // PRESENT?
149 var present: i64 = 0
150 let gl: i64 = mc_len(gate)
151 if gl == 1 { if gate[0] == (45 as u8) { present = 0 } else { present = mc_tag_green(lbuf, ln, gate, gl) } }
152 else { present = mc_tag_green(lbuf, ln, gate, gl) }
153 tw[ci] = tw[ci] + wv; tw[3] = tw[3] + wv
154 tc[ci] = tc[ci] + 1; tc[3] = tc[3] + 1
155 if present == 1 { pw[ci] = pw[ci] + wv; pw[3] = pw[3] + wv; pc[ci] = pc[ci] + 1; pc[3] = pc[3] + 1 }
156 if mfd >= 0 {
157 mc_w(mfd, idf); mc_w(mfd, "\t" as *u8); mc_w(mfd, cat); mc_w(mfd, "\t" as *u8); mc_w(mfd, feat); mc_w(mfd, "\t" as *u8)
158 if present == 1 { mc_w(mfd, "PRESENT" as *u8) } else { mc_w(mfd, "ABSENT" as *u8) }
159 mc_w(mfd, "\t" as *u8); mc_wn(mfd, wv); mc_w(mfd, "\n" as *u8)
160 }
161 if present == 0 { if abo < MC_MAGIC_7900 { var y: i64 = 0; while idf[y] != (0 as u8) { absbuf[abo] = idf[y]; abo = abo + 1; y = y + 1 } absbuf[abo] = 32 as u8; abo = abo + 1 } }
162 }
163 } }
164 ls = i + 1
165 }
166 i = i + 1
167 }
168 if mfd >= 0 { sys_close(mfd) }
169 absbuf[abo] = 0 as u8
170
171 // reach permil helper
172 var reach: i64 = 0
173 if tw[3] > 0 { reach = (pw[3] * 1000) / tw[3] }
174 var rd: i64 = 0
175 if tw[0] > 0 { rd = (pw[0] * 1000) / tw[0] }
176 var rg: i64 = 0
177 if tw[1] > 0 { rg = (pw[1] * 1000) / tw[1] }
178 var rwf: i64 = 0
179 if tw[2] > 0 { rwf = (pw[2] * 1000) / tw[2] }
180
181 var p2: i64 = 0
182 while p2 < 2 {
183 var fd: i64 = 1
184 if p2 == 1 { fd = sys_openat_append(MC_OUT, 0x1a4) }
185 if fd >= 0 {
186 mc_w(fd, "MATHCENSUS present=" as *u8); mc_wn(fd, pc[3]); mc_w(fd, "/" as *u8); mc_wn(fd, tc[3])
187 mc_w(fd, " reach_permil=" as *u8); mc_wn(fd, reach)
188 mc_w(fd, " dlmf=" as *u8); mc_wn(fd, rd)
189 mc_w(fd, " gams=" as *u8); mc_wn(fd, rg)
190 mc_w(fd, " wolfram=" as *u8); mc_wn(fd, rwf)
191 if reach >= 1000 { mc_w(fd, " verdict=NIST-EXCEED\n" as *u8) } else { mc_w(fd, " verdict=BEHIND\n" as *u8) }
192 if p2 == 1 { sys_close(fd) }
193 }
194 p2 = p2 + 1
195 }
196 mc_w(1, "ABSENT (the backlog to S-class-exceed): " as *u8); mc_w(1, absbuf); mc_w(1, "\n" as *u8)
197 sys_exit(0)
198 return 0
199}