nx_nofloat_exceed_gate.nx source

1// nx_nofloat_exceed_gate.nx -- the UNIQUE Nishi exceed axis: NO-FLOAT determinism. 2// Operator's differentiator for image/video/LLM/coding models: build on INTEGER/fixed-point, not float. 3// WHY it is S-class exceed (not raw speed -- DETERMINISM + EXACTNESS): float add is NON-ASSOCIATIVE, so the 4// SAME dot product gives DIFFERENT bits when summed in a different order (or on different hardware / thread 5// counts). Integer accumulation is associative + exact -> BIT-IDENTICAL across every ordering, every machine, 6// forever. For a CODING model this is decisive: same prompt -> same code, reproducibly. sdcpp/GGML/llama.cpp 7// accumulate in float = non-deterministic by construction; the no-float stack does not. This proves the axis 8// on one dot: a=[2^24,1,1,1,1] . b=[1,1,1,1,1] = 16777220 exactly. No hw writes (Rule 26). 9// expect_exit: 0 license_tier: ORIGINAL 10import "nx_syscalls.nx" 11import "nx_gate_verdict.nx" 12 13func nf_puts(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 } 14func nf_num(v: i64) -> i64 { let b: *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 as u8;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{b[i]=t[k-1-i];i=i+1} sys_write(1,b,k); return 0 } 15 16func main() -> i64 { 17 nf_puts("NO-FLOAT EXCEED AXIS: integer is EXACT + DETERMINISTic where float is lossy + order-dependent\n\n" as *u8) 18 let K: i64=5 19 let ai: *i64 = sys_mmap(K*8) as *i64 20 let bi: *i64 = sys_mmap(K*8) as *i64 21 ai[0]=16777216; ai[1]=1; ai[2]=1; ai[3]=1; ai[4]=1 // 2^24 then four 1s 22 bi[0]=1; bi[1]=1; bi[2]=1; bi[3]=1; bi[4]=1 23 let exact: i64 = 16777220 // 2^24 + 4, the true dot 24 25 // ---- NO-FLOAT (integer fixed-point Q0) dot, two orderings ---- 26 var ifwd: i64=0 27 var k: i64=0 28 while k<K { ifwd = ifwd + ai[k]*bi[k]; k=k+1 } 29 var irev: i64=0 30 k=K-1 31 while k>=0 { irev = irev + ai[k]*bi[k]; k=k-1 } 32 33 // ---- FLOAT (hardware f32) dot, two orderings ---- 34 let af: *i64 = sys_mmap(K*8) as *i64 35 let bf: *i64 = sys_mmap(K*8) as *i64 36 k=0 37 while k<K { af[k]=__f32_from_i64(ai[k]); bf[k]=__f32_from_i64(bi[k]); k=k+1 } 38 var ffwd: i64=__f32_from_i64(0) 39 k=0 40 while k<K { ffwd=__f32_add(ffwd, __f32_mul(af[k], bf[k])); k=k+1 } 41 var frev: i64=__f32_from_i64(0) 42 k=K-1 43 while k>=0 { frev=__f32_add(frev, __f32_mul(af[k], bf[k])); k=k-1 } 44 let ffwd_i: i64 = __f32_to_i64(ffwd) 45 let frev_i: i64 = __f32_to_i64(frev) 46 47 nf_puts(" dot a=[2^24,1,1,1,1] . b=[1,1,1,1,1] true answer = "); nf_num(exact); nf_puts("\n\n"); 48 nf_puts(" NO-FLOAT (integer): forward="); nf_num(ifwd); nf_puts(" reverse="); nf_num(irev); nf_puts(" -> identical + exact\n"); 49 nf_puts(" FLOAT (f32): forward="); nf_num(ffwd_i); nf_puts(" reverse="); nf_num(frev_i); nf_puts(" -> DIFFER (non-associative) + forward LOST the small terms\n\n"); 50 51 var pass: i64=0 52 var ttl: i64=0 53 ttl=ttl+1; nf_puts(" T1 NO-FLOAT DETERMINISTIC: integer forward == reverse (associative, order cannot change the bits): "); if ifwd==irev { pass=pass+1; nf_puts("PASS\n") } else { nf_puts("FAIL\n") } 54 ttl=ttl+1; nf_puts(" T2 NO-FLOAT EXACT: integer == the true answer "); nf_num(exact); nf_puts(": "); if ifwd==exact { pass=pass+1; nf_puts("PASS\n") } else { nf_puts("FAIL\n") } 55 ttl=ttl+1; nf_puts(" T3 FLOAT NON-DETERMINISTIC: f32 forward != reverse (same dot, different bits by order): "); if ffwd_i != frev_i { pass=pass+1; nf_puts("PASS\n") } else { nf_puts("FAIL\n") } 56 ttl=ttl+1; nf_puts(" T4 FLOAT LOSSY: f32 forward != exact (precision lost) while integer is exact: "); if ffwd_i != exact { pass=pass+1; nf_puts("PASS\n") } else { nf_puts("FAIL\n") } 57 58 nf_puts("NX-NOFLOAT-EXCEED-GATE passed "); nf_num(pass); nf_puts("/"); nf_num(ttl) 59 // MIGRATED onto nx_gate_verdict by nx_gate_dry_apply (D001, minimal form): every check 60 // row above is untouched, so the PASS/FAIL vector cannot change; only the hand-rolled 61 // verdict emission is replaced by the ONE shared base class. Proven by nx_gate_migrate verify. 62 let ctr__dry: *i64 = gv_ctr() 63 ctr__dry[0] = pass 64 ctr__dry[1] = ttl 65 let rc__dry: i64 = gv_verdict("NOFLOAT-EXCEED-GATE" as *u8, ctr__dry, "no-float = EXACT + DETERMINISTIC = the unique exceed axis for reproducible sovereign models)" as *u8) 66 sys_exit(rc__dry) 67 return rc__dry 68}