code wiki / _hdl_build / nx_math_scorecard.nx
nx_math_scorecard.nx source
↩ module page · 149 lines · 6349 B
1// nx_math_scorecard.nx -- the NIST-exceed instrument: MECHANICAL DLMF/GAMS coverage
2// scorecard for the math-engine arc. Evidence-driven-live-grading law: every cell is
3// derived from knowledge/status/math_engine.log GREEN gate rows; nothing is asserted.
4// "Better than Wolfram/NIST-listed engines" only ever appears as verdict=NIST-EXCEED,
5// and that verdict requires EVERY chapter row at target AND a won perf race row --
6// today's output is the HONEST baseline (verdict=ON-LADDER, tiny coverage).
7//
8// Data-driven (rule 11): the requirement table is DATA rows (tag, class-id, weight),
9// growing the engine = adding rows here + gates in the log, never editing logic.
10// Class ids: 0=ARITH(IEEE754 core) 1=DLMF-ch4(elementary) 2=DLMF-ch5(gamma)
11// 3=DLMF-ch7(erf) 4=DLMF-ch10(bessel) 5=PERF(races won)
12//
13// Output: MATHSCORE line -> stdout + append knowledge/status/math_scorecard.log
14// license_tier: ORIGINAL
15
16import "nx_syscalls.nx"
17const MS_MAGIC_262144: i64 = 262144
18const MS_MAGIC_262143: i64 = 262143
19
20func ms_puts(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 }
21func ms_putn(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); 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 }
22
23// requirement table: per row a TAG (gate log marker) and its class.
24// targets per class live in ms_class_target. Add rows as the ladder climbs.
25func ms_row_tag(i: i64) -> *u8 {
26 if i == 0 { return "F64GATE" as *u8 }
27 if i == 1 { return "EXPGATE" as *u8 }
28 if i == 2 { return "LOGGATE" as *u8 }
29 if i == 3 { return "SINGATE" as *u8 }
30 if i == 4 { return "COSGATE" as *u8 }
31 if i == 5 { return "TANGATE" as *u8 }
32 if i == 6 { return "ATANGATE" as *u8 }
33 if i == 7 { return "POWGATE" as *u8 }
34 if i == 8 { return "SINHGATE" as *u8 }
35 if i == 9 { return "COSHGATE" as *u8 }
36 if i == 10 { return "GAMMAGATE" as *u8 }
37 if i == 11 { return "LGAMMAGATE" as *u8 }
38 if i == 12 { return "ERFGATE" as *u8 }
39 if i == 13 { return "ERFCGATE" as *u8 }
40 if i == 14 { return "BESSELJGATE" as *u8 }
41 if i == 15 { return "BESSELYGATE" as *u8 }
42 if i == 16 { return "PERFRACE" as *u8 }
43 return "" as *u8
44}
45
46func ms_row_class(i: i64) -> i64 {
47 if i == 0 { return 0 }
48 if i <= 9 { return 1 }
49 if i <= 11 { return 2 }
50 if i <= 13 { return 3 }
51 if i <= 15 { return 4 }
52 return 5
53}
54
55const MS_NROWS: i64 = 17
56const MS_NCLASS: i64 = 6
57
58// does buf contain a line STARTING with the tag, followed (anywhere later in
59// the line) by "verdict=GREEN"? Line-anchored: a substring hit would let
60// ATANGATE rows credit TANGATE (and LGAMMAGATE credit GAMMAGATE) -- caught
61// live when the atan rung landed and ch4 jumped 2 rows for 1 gate.
62func ms_tag_green(buf: *u8, n: i64, tag: *u8) -> i64 {
63 var tl: i64 = 0
64 while tag[tl] != (0 as u8) { tl = tl + 1 }
65 if tl == 0 { return 0 }
66 var i: i64 = 0
67 while i + tl <= n {
68 var hit: i64 = 1
69 if i > 0 { if buf[i - 1] != (10 as u8) { hit = 0 } }
70 var j: i64 = 0
71 while j < tl {
72 if hit == 0 { j = tl } else {
73 if buf[i + j] != tag[j] { hit = 0; j = tl } else { j = j + 1 }
74 }
75 }
76 if hit == 1 {
77 // scan to end of line looking for "verdict=GREEN"
78 let g: *u8 = "verdict=GREEN" as *u8
79 var p: i64 = i
80 while p < n {
81 if buf[p] == (10 as u8) { p = n } else {
82 var q: i64 = 0
83 var gh: i64 = 1
84 while q < 13 {
85 if p + q >= n { gh = 0; q = 13 } else {
86 if buf[p + q] != g[q] { gh = 0; q = 13 } else { q = q + 1 }
87 }
88 }
89 if gh == 1 { return 1 }
90 p = p + 1
91 }
92 }
93 }
94 i = i + 1
95 }
96 return 0
97}
98
99func main() -> i64 {
100 let buf: *u8 = sys_mmap(MS_MAGIC_262144)
101 let fd: i64 = sys_openat_rd("knowledge/status/math_engine.log" as *u8)
102 var n: i64 = 0
103 if fd >= 0 {
104 var r: i64 = sys_read(fd, buf, MS_MAGIC_262143)
105 while r > 0 { n = n + r; r = sys_read(fd, buf + n, MS_MAGIC_262143 - n) }
106 sys_close(fd)
107 }
108
109 let green: *i64 = sys_mmap(8 * 8) as *i64 // green count per class
110 let total: *i64 = sys_mmap(8 * 8) as *i64 // row count per class
111 var i: i64 = 0
112 while i < MS_NROWS {
113 let cls: i64 = ms_row_class(i)
114 total[cls] = total[cls] + 1
115 if ms_tag_green(buf, n, ms_row_tag(i)) == 1 { green[cls] = green[cls] + 1 }
116 i = i + 1
117 }
118
119 let lf: i64 = sys_openat_append("knowledge/status/math_scorecard.log" as *u8, 0x1a4)
120 var fdo: i64 = 1
121 var pass2: i64 = 0
122 while pass2 < 2 {
123 ms_puts(fdo, "MATHSCORE" as *u8)
124 ms_puts(fdo, " arith=" as *u8); ms_putn(fdo, (green[0] * 1000) / total[0])
125 ms_puts(fdo, " dlmf_ch4=" as *u8); ms_putn(fdo, (green[1] * 1000) / total[1])
126 ms_puts(fdo, " dlmf_ch5=" as *u8); ms_putn(fdo, (green[2] * 1000) / total[2])
127 ms_puts(fdo, " dlmf_ch7=" as *u8); ms_putn(fdo, (green[3] * 1000) / total[3])
128 ms_puts(fdo, " dlmf_ch10=" as *u8); ms_putn(fdo, (green[4] * 1000) / total[4])
129 ms_puts(fdo, " perf=" as *u8); ms_putn(fdo, (green[5] * 1000) / total[5])
130 var gsum: i64 = 0
131 var tsum: i64 = 0
132 var c: i64 = 0
133 while c < MS_NCLASS { gsum = gsum + green[c]; tsum = tsum + total[c]; c = c + 1 }
134 ms_puts(fdo, " overall=" as *u8); ms_putn(fdo, (gsum * 1000) / tsum)
135 // NIST-EXCEED = every class full AND perf race won; else ON-LADDER (honest).
136 var full: i64 = 1
137 c = 0
138 while c < MS_NCLASS { if green[c] < total[c] { full = 0 } c = c + 1 }
139 if full == 1 {
140 ms_puts(fdo, " verdict=NIST-EXCEED\n" as *u8)
141 } else {
142 ms_puts(fdo, " verdict=ON-LADDER\n" as *u8)
143 }
144 fdo = lf
145 if lf < 0 { pass2 = 2 } else { pass2 = pass2 + 1 }
146 }
147 if lf >= 0 { sys_close(lf) }
148 return 0
149}