code wiki / _hdl_build / nx_battery_grade.nx
nx_battery_grade.nx source
↩ module page · 174 lines · 6908 B
1// nx_battery_grade.nx -- THE UNIVERSAL ANSWER-KEY JUDGE, Nishi first byte up (operator oracle-only law).
2// One generic grader for every key-scored battery on the model card: F786 reasoning/chat MCQ,
3// F788 agentic tool-choice, F789 factuality QA. A SEAT or ORACLE only ever writes answer rows;
4// THIS organ owns the join, the contract and the score -- so a graded number can never be
5// self-asserted by the thing being measured.
6// key plane row : id<TAB>expected<TAB>[note] (the answer key)
7// answer plane row : id<TAB>given<TAB>[epoch]<TAB>[actor] (seat/oracle-written via nx_store_put;
8// id-replace = dedup at the store layer)
9// contract: exact string match on col1; UNANSWERED COUNTS AS WRONG (coverage cannot inflate the
10// score); zero answer rows -> verdict=UNMEASURED (fabrication has no code path); empty key ->
11// verdict=RED fail-loud. score_pct = correct*100/total-keys. Atomic publish to <outpath>.
12// nx_battery_grade <keyprefix> <ansprefix> <outpath>
13// expect_exit: 0 (GREEN|UNMEASURED) | 1 RED | 2 usage license_tier: ORIGINAL No hw writes (Rule 26).
14import "nx_store_seed_lib.nx"
15import "nx_seg_store.nx"
16import "nx_syscalls.nx"
17
18static g_correct: i64
19static g_wrong: i64
20static g_unans: i64
21
22const KG_CAP: i64 = 1048576
23const KG_OCAP: i64 = 8192
24const KG_PATHCAP: i64 = 256
25const KG_TAB: i64 = 9
26const KG_NL: i64 = 10
27const KG_STDERR: i64 = 2
28const KG_MODE: i64 = 0x1a4
29const KG_D0: i64 = 48
30const KG_B10: i64 = 10
31const KG_NUMB: i64 = 24
32const KG_EXIT_RED: i64 = 1
33const KG_EXIT_USAGE: i64 = 2
34
35func kg_slen(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
36func kg_werr(s: *u8) -> i64 { sys_write(KG_STDERR, s, kg_slen(s)); return 0 }
37func kg_cat(d: *u8, off: i64, s: *u8) -> i64 {
38 var o: i64 = off
39 var j: i64 = 0
40 while s[j] != (0 as u8) { d[o] = s[j]; o = o + 1; j = j + 1 }
41 return o
42}
43func kg_catn(d: *u8, off: i64, v: i64) -> i64 {
44 var o: i64 = off
45 var m: i64 = v
46 if m == 0 { d[o] = KG_D0 as u8; return o + 1 }
47 if m < 0 { m = 0 - m }
48 let t: *u8 = sys_mmap(KG_NUMB)
49 var k: i64 = 0
50 while m > 0 { t[k] = (KG_D0 + (m % KG_B10)) as u8; m = m / KG_B10; k = k + 1 }
51 var i: i64 = 0
52 while i < k { d[o] = t[k - 1 - i]; o = o + 1; i = i + 1 }
53 return o
54}
55// end of line starting at i (index of NL or n)
56func kg_eol(buf: *u8, n: i64, i: i64) -> i64 {
57 var le: i64 = i
58 var s: i64 = 1
59 while s == 1 { if le >= n { s = 0 } else { if buf[le] == (KG_NL as u8) { s = 0 } else { le = le + 1 } } }
60 return le
61}
62// end of field starting at i within [i,le): index of TAB or le
63func kg_eof(buf: *u8, le: i64, i: i64) -> i64 {
64 var t: i64 = i
65 var s: i64 = 1
66 while s == 1 { if t >= le { s = 0 } else { if buf[t] == (KG_TAB as u8) { s = 0 } else { t = t + 1 } } }
67 return t
68}
69func kg_slice_eq(a: *u8, as1: i64, ae: i64, b: *u8, bs: i64, be: i64) -> i64 {
70 if ae - as1 != be - bs { return 0 }
71 var i: i64 = 0
72 while as1 + i < ae { if a[as1+i] != b[bs+i] { return 0 } i = i + 1 }
73 return 1
74}
75// find the answer row whose col0 == key id slice; return 1 + set given slice via statics
76static g_gs: i64
77static g_ge: i64
78func kg_lookup(ab: *u8, an: i64, kb: *u8, ida: i64, idb: i64) -> i64 {
79 var i: i64 = 0
80 while i < an {
81 let le: i64 = kg_eol(ab, an, i)
82 if le > i {
83 let t0: i64 = kg_eof(ab, le, i)
84 if kg_slice_eq(ab, i, t0, kb, ida, idb) == 1 {
85 if t0 < le {
86 let t1: i64 = kg_eof(ab, le, t0 + 1)
87 g_gs = t0 + 1
88 g_ge = t1
89 return 1
90 }
91 return 0
92 }
93 }
94 i = le + 1
95 }
96 return 0
97}
98
99func main(argc: i64, argv: *i64) -> i64 {
100 if argc < 4 { kg_werr("usage: nx_battery_grade <keyprefix> <ansprefix> <outpath>\n" as *u8); sys_exit(KG_EXIT_USAGE); return KG_EXIT_USAGE }
101 let kp: *u8 = argv[1] as *u8
102 let ap: *u8 = argv[2] as *u8
103 let op: *u8 = argv[3] as *u8
104
105 let kb: *u8 = sys_mmap(KG_CAP)
106 let kn: i64 = sts_load(kp, kb, KG_CAP - 16)
107 if kn <= 0 { kg_werr("BATTERY-GRADE FAIL verdict=RED key plane EMPTY\n" as *u8); sys_exit(KG_EXIT_RED); return KG_EXIT_RED }
108 let ab: *u8 = sys_mmap(KG_CAP)
109 let an: i64 = sts_load(ap, ab, KG_CAP - 16)
110
111 g_correct = 0
112 g_wrong = 0
113 g_unans = 0
114 var total: i64 = 0
115 var i: i64 = 0
116 while i < kn {
117 let le: i64 = kg_eol(kb, kn, i)
118 if le > i {
119 total = total + 1
120 let t0: i64 = kg_eof(kb, le, i)
121 if t0 < le {
122 let t1: i64 = kg_eof(kb, le, t0 + 1)
123 if an > 0 {
124 if kg_lookup(ab, an, kb, i, t0) == 1 {
125 if kg_slice_eq(kb, t0 + 1, t1, ab, g_gs, g_ge) == 1 { g_correct = g_correct + 1 } else { g_wrong = g_wrong + 1 }
126 } else { g_unans = g_unans + 1 }
127 } else { g_unans = g_unans + 1 }
128 } else { g_wrong = g_wrong + 1 }
129 }
130 i = le + 1
131 }
132
133 let out: *u8 = sys_mmap(KG_OCAP)
134 var o: i64 = 0
135 let answered: i64 = g_correct + g_wrong
136 if answered == 0 {
137 o = kg_cat(out, o, "BATTERY-GRADE verdict=UNMEASURED total=" as *u8)
138 o = kg_catn(out, o, total)
139 o = kg_cat(out, o, " answered=0 (no answer rows; a seat/oracle must sit the battery -- honest-numbers law, no fabrication)\n" as *u8)
140 } else {
141 let pct: i64 = (g_correct * 100) / total
142 o = kg_cat(out, o, "BATTERY-GRADE verdict=GREEN correct=" as *u8)
143 o = kg_catn(out, o, g_correct)
144 o = kg_cat(out, o, " wrong=" as *u8)
145 o = kg_catn(out, o, g_wrong)
146 o = kg_cat(out, o, " unanswered=" as *u8)
147 o = kg_catn(out, o, g_unans)
148 o = kg_cat(out, o, " total=" as *u8)
149 o = kg_catn(out, o, total)
150 o = kg_cat(out, o, " score_pct=" as *u8)
151 o = kg_catn(out, o, pct)
152 o = kg_cat(out, o, " (exact-match col1; unanswered counts wrong; Nishi computed this, the seat only wrote answers)\n" as *u8)
153 }
154 o = kg_cat(out, o, "epoch=" as *u8)
155 o = kg_catn(out, o, sys_now_realtime_sec())
156 o = kg_cat(out, o, " key=" as *u8)
157 o = kg_cat(out, o, kp)
158 o = kg_cat(out, o, " ans=" as *u8)
159 o = kg_cat(out, o, ap)
160 o = kg_cat(out, o, "\n" as *u8)
161
162 let tp: *u8 = sys_mmap(KG_PATHCAP)
163 var to: i64 = kg_cat(tp, 0, op)
164 to = kg_cat(tp, to, ".nxtmp" as *u8)
165 tp[to] = 0 as u8
166 let fd: i64 = sys_openat_wr(tp, KG_MODE)
167 if fd < 0 { kg_werr("BATTERY-GRADE FAIL verdict=RED publish-open\n" as *u8); sys_exit(KG_EXIT_RED); return KG_EXIT_RED }
168 sys_write(fd, out, o)
169 sys_close(fd)
170 if sys_renameat(tp, op) < 0 { kg_werr("BATTERY-GRADE FAIL verdict=RED publish-rename\n" as *u8); sys_exit(KG_EXIT_RED); return KG_EXIT_RED }
171 sys_write(KG_STDERR, out, o)
172 sys_exit(0)
173 return 0
174}