nx_engineer_wire_test.nx source

1// nx_engineer_wire_test.nx -- the ENGINEER wires the BM25 ranker into the library search and CERTIFIES 2// the swap before it is accepted. It runs the OLD ranker (ls_best, TF-IDF) and the NEW one 3// (ls_best_bm25) over a labelled query set, then checks non-regression + improvement: 4// Q1 "injury" (length-bias) ground-truth = doc0 (short focused). old TF-IDF picks doc1 (diluted, WRONG); 5// BM25 picks doc0 (RIGHT) -> an improvement. 6// Q2 "court" ground-truth = doc3. both rankers pick doc3 -> no regression. 7// Verdict must be WIRED_OK (0 regressions, >=1 improvement). It also proves the gate REJECTS a regressing 8// swap. Exit 0 on 6/6. license_tier: ORIGINAL 9 10import "nx_engineer_wire.nx" 11import "nx_library_search.nx" // ls_best (old TF-IDF) + ls_best_bm25 (new, wired) 12import "nx_research_extract.nx" // re_strlen 13import "nx_syscalls.nx" 14 15func wt_puts(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 } 16func wt_num(v: i64) -> i64 { let bb: *u8 = sys_mmap(28); var m: i64=v; if m<0 {m=0-m; sys_write(1,"-" 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(1, bb, k); return 0 } 17 18func main() -> i64 { 19 wt_puts("=== ENGINEER: wire BM25 into the library search, certify the swap ===\n" as *u8) 20 let N: i64 = 4 21 let d0: *u8 = "injury injury" as *u8 22 let d1: *u8 = "injury injury injury f f f f f f f f f" as *u8 23 let d2: *u8 = "settlement settlement filler" as *u8 24 let d3: *u8 = "court court court" as *u8 25 let ptrs: *i64 = sys_mmap(8 * 8) as *i64; let lens: *i64 = sys_mmap(8 * 8) as *i64 26 ptrs[0]=d0 as i64; ptrs[1]=d1 as i64; ptrs[2]=d2 as i64; ptrs[3]=d3 as i64 27 var i: i64 = 0; while i < N { lens[i] = re_strlen(ptrs[i] as *u8); i = i + 1 } 28 29 let q1: *i64 = sys_mmap(4 * 8) as *i64; q1[0]="injury" as *u8 as i64 30 let q2: *i64 = sys_mmap(4 * 8) as *i64; q2[0]="court" as *u8 as i64 31 32 // run both rankers over the query set 33 let old1: i64 = ls_best(ptrs, lens, N, q1, 1) 34 let new1: i64 = ls_best_bm25(ptrs, lens, N, q1, 1) 35 let old2: i64 = ls_best(ptrs, lens, N, q2, 1) 36 let new2: i64 = ls_best_bm25(ptrs, lens, N, q2, 1) 37 38 // ground truth + correctness vectors 39 let gt: *i64 = sys_mmap(4 * 8) as *i64; gt[0]=0; gt[1]=3 // Q1->doc0, Q2->doc3 40 let oldc: *i64 = sys_mmap(4 * 8) as *i64; let newc: *i64 = sys_mmap(4 * 8) as *i64 41 oldc[0]=0; if old1==gt[0] { oldc[0]=1 } ; newc[0]=0; if new1==gt[0] { newc[0]=1 } 42 oldc[1]=0; if old2==gt[1] { oldc[1]=1 } ; newc[1]=0; if new2==gt[1] { newc[1]=1 } 43 44 let regr: i64 = ew_regressions(2, oldc, newc) 45 let impr: i64 = ew_improvements(2, oldc, newc) 46 let verdict: i64 = ew_verdict(regr, impr) 47 let safe: i64 = ew_safe_to_wire(verdict) 48 wt_puts(" Q1 'injury': old(TF-IDF)->doc" as *u8); wt_num(old1); wt_puts(" new(BM25)->doc" as *u8); wt_num(new1); wt_puts(" (gt=doc0)\n" as *u8) 49 wt_puts(" Q2 'court' : old->doc" as *u8); wt_num(old2); wt_puts(" new->doc" as *u8); wt_num(new2); wt_puts(" (gt=doc3)\n" as *u8) 50 wt_puts(" CERTIFY: regressions=" as *u8); wt_num(regr); wt_puts(" improvements=" as *u8); wt_num(impr); wt_puts(" verdict=" as *u8); wt_num(verdict); wt_puts(" (2=WIRED_OK) safe-to-wire=" as *u8); wt_num(safe); wt_puts("\n" as *u8) 51 52 // the gate must REJECT a regressing swap (old right, new wrong) 53 let bo: *i64 = sys_mmap(4 * 8) as *i64; let bn: *i64 = sys_mmap(4 * 8) as *i64 54 bo[0]=1; bo[1]=1; bn[0]=1; bn[1]=0 55 let badv: i64 = ew_verdict(ew_regressions(2, bo, bn), ew_improvements(2, bo, bn)) 56 57 let r: *i64 = sys_mmap(8 * 8) as *i64 58 r[0] = 0; if regr == 0 { r[0] = 1 } // BM25 broke nothing 59 r[1] = 0; if impr >= 1 { r[1] = 1 } // BM25 fixed the length-bias query 60 r[2] = 0; if verdict == EW_OK { r[2] = 1 } // verdict WIRED_OK 61 r[3] = 0; if safe == 1 { r[3] = 1 } // safe to wire 62 r[4] = 0; if badv == EW_REGRESS { if ew_safe_to_wire(badv) == 0 { r[4] = 1 } } // gate rejects a regression 63 r[5] = 0; if new1 == 0 { if new2 == 3 { r[5] = 1 } } // the wired ranker is actually correct on both 64 var pass: i64 = 0; i = 0 65 while i < 6 { pass = pass + r[i]; i = i + 1 } 66 wt_puts("----\n passed " as *u8); wt_num(pass); wt_puts("/6\n" as *u8) 67 if pass == 6 { wt_puts(" WIRED + CERTIFIED: BM25 is now the library search's ranker -- non-regressing, fixes the length bias, and the Engineer's gate would reject any regressing swap.\n" as *u8); sys_exit(0); return 0 } 68 wt_puts(" FAIL\n" as *u8); sys_exit(1); return 1 69}