nx_quality_raci_test.nx source

1// nx_quality_raci_test.nx -- proves the feature is ROBUST and correctly DISTRIBUTED across organs: 2// ENGINEER diagnoses the bound, BUILDER decides the operating point under the COUNCIL's quality 3// policy. Exit 0 only if every check holds. 4// (1) decode matvec (Q4) -> Engineer: MEMORY-bound, lever=DATA. 5// (2) Builder, balancing quality(slightly>speed) under the Council floor, picks Q4_K_M -- which 6// the published data independently calls the best quality/size balance. NOT the fastest. 7// (3) contrast: a pure-SPEED choice would pick Q2_K (smallest, +8.82% perplexity) -> proves the 8// balance is doing real work, and quality is being protected. 9// (4) compute-bound kernel -> Builder keeps HIGHEST quality (bytes don't bind; no quality sacrifice). 10// (5) COUNCIL floor rejects Q2_K/Q3_K_M, admits Q4_K_M. 11// (6) ROBUSTNESS: invalid input (0 bytes) -> RF_UNKNOWN (no silent verdict); a 4-exabyte kernel 12// (overflow range) still returns a valid bound; all-below-floor -> graceful highest-quality. 13// license_tier: ORIGINAL 14 15import "nx_builder_quant.nx" // Builder (pulls Engineer + Council-governed quality balance) 16import "nx_syscalls.nx" 17 18func qt_puts(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 } 19func qt_num(v: i64) -> i64 { let bb: *u8 = sys_mmap(28); var m: i64=v; if m<0 {m=0-m}; 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 } 20 21func main() -> i64 { 22 qt_puts("=== RACI: Engineer diagnoses -> Builder decides under Council quality policy ===\n" as *u8) 23 // the real llama.cpp quant menu: index name loss_permil bits10 24 // 0 fp16(0,160) 1 Q8_0(1,85) 2 Q6_K(2,66) 3 Q5_K_M(4,55) 4 Q4_K_M(12,45) 5 Q3_K_M(47,34) 6 Q2_K(88,26) 25 let loss: *i64 = sys_mmap(8*8) as *i64 26 let bits: *i64 = sys_mmap(8*8) as *i64 27 loss[0]=0; bits[0]=160 28 loss[1]=1; bits[1]=85 29 loss[2]=2; bits[2]=66 30 loss[3]=4; bits[3]=55 31 loss[4]=12; bits[4]=45 32 loss[5]=47; bits[5]=34 33 loss[6]=88; bits[6]=26 34 let NQ: i64 = 7 35 let pf: i64 = 384 36 let pb: i64 = 45 37 let N: i64 = 4096 38 let mv_flops: i64 = 2 * N * N 39 let mv_bytes: i64 = (N * N * 9) / 16 40 let mm_flops: i64 = 2 * N * N * 64 41 42 let r: *i64 = sys_mmap(8*16) as *i64 43 44 // (1) Engineer diagnoses decode matvec 45 let bound: i64 = eng_diagnose_kernel(mv_flops, mv_bytes, pf, pb) 46 let lever: i64 = eng_recommend_lever(bound) 47 qt_puts(" [Engineer] decode matvec -> bound=" as *u8); qt_num(bound); qt_puts(" lever=" as *u8); qt_num(lever); qt_puts(" (1=DATA)\n" as *u8) 48 r[0] = 0; if bound == RF_MEMORY_BOUND { if lever == ENG_LEVER_DATA { r[0] = 1 } } 49 50 // (2) Builder picks the quality-balanced operating point (expect Q4_K_M = idx 4) 51 let pick: i64 = bld_select_operating_point(mv_flops, mv_bytes, pf, pb, NQ, loss, bits) 52 qt_puts(" [Builder] balanced pick (memory-bound) = idx " as *u8); qt_num(pick); qt_puts(" (expect 4 = Q4_K_M)\n" as *u8) 53 r[1] = 0; if pick == 4 { r[1] = 1 } 54 55 // (3) contrast: pure-speed would pick Q2_K (idx 6) -> proves the balance protects quality 56 let fast: i64 = qb_select_speed_only(NQ, bits) 57 qt_puts(" [contrast] pure-speed pick = idx " as *u8); qt_num(fast); qt_puts(" (Q2_K, +8.82% ppl -- rejected by balance)\n" as *u8) 58 r[2] = 0; if fast == 6 { if pick != fast { r[2] = 1 } } 59 60 // (4) compute-bound kernel -> Builder keeps highest quality (idx 0) 61 let pick_cb: i64 = bld_select_operating_point(mm_flops, mv_bytes, pf, pb, NQ, loss, bits) 62 qt_puts(" [Builder] compute-bound pick = idx " as *u8); qt_num(pick_cb); qt_puts(" (expect 0 = highest quality)\n" as *u8) 63 r[3] = 0; if pick_cb == 0 { r[3] = 1 } 64 65 // (5) Council floor: reject Q2_K(88) & Q3_K_M(47), admit Q4_K_M(12) 66 r[4] = 0 67 if council_quality_admit(88, QB_QUALITY_FLOOR) == 0 { if council_quality_admit(47, QB_QUALITY_FLOOR) == 0 { if council_quality_admit(12, QB_QUALITY_FLOOR) == 1 { r[4] = 1 } } } 68 69 // (6) ROBUSTNESS 70 let bad: i64 = eng_diagnose_kernel(mv_flops, 0, pf, pb) // 0 bytes -> no silent verdict 71 let huge: i64 = rf_bound(8000000000000000000, 4000000000000000000, pf, pb) // ~exabyte, overflow range 72 qt_puts(" [robust] 0-bytes bound=" as *u8); qt_num(bad); qt_puts(" (0=UNKNOWN) exabyte bound=" as *u8); qt_num(huge); qt_puts(" (valid 1/2)\n" as *u8) 73 r[5] = 0 74 if bad == RF_UNKNOWN { if huge == RF_MEMORY_BOUND { r[5] = 1 } } 75 // all-below-floor -> graceful highest-quality fallback (never ship nothing) 76 let lossy: *i64 = sys_mmap(8*4) as *i64; let lb: *i64 = sys_mmap(8*4) as *i64 77 lossy[0]=200; lb[0]=40; lossy[1]=150; lb[1]=34 78 let grace: i64 = qb_select(2, lossy, lb, QB_QUALITY_FLOOR) 79 qt_puts(" [robust] all-below-floor -> graceful idx " as *u8); qt_num(grace); qt_puts(" (1 = least-lossy)\n" as *u8) 80 r[6] = 0; if grace == 1 { r[6] = 1 } 81 82 var pass: i64 = 0; var i: i64 = 0 83 while i < 7 { pass = pass + r[i]; i = i + 1 } 84 qt_puts("----\n passed " as *u8); qt_num(pass); qt_puts("/7\n" as *u8) 85 if pass == 7 { qt_puts(" ROBUST + WIRED: Engineer diagnoses, Builder balances quality>speed under Council floor.\n" as *u8); sys_exit(0); return 0 } 86 qt_puts(" FAIL\n" as *u8); sys_exit(1); return 1 87}