nx_netquant_gate.nx source

1// nx_netquant_gate.nx -- proves + MEASURES the sovereign bit-packed/delta state codec 2// (nx_netquant) that keeps a bad-mobile-network player smooth. Shows the real bit budget. 3// 1) FULL keyframe round-trips EXACTLY (lossless for in-range values) -- measured 88 bits/11 B 4// 2) BIT BUDGET: full < raw 28-byte frame (measured compression) 5// 3) DELTA stationary -> tiny (~mask only); round-trips exact 6// 4) DELTA small move < FULL (the low-bandwidth win) + round-trips exact 7// 5) WALK PATH: 16 frames delta-coded -> measured avg bytes/snapshot vs full vs raw 8// 6) anti-tautology (neg): a delta on the WRONG baseline gives a WRONG result 9// (proves it is genuinely baseline-relative, not secretly absolute) 10// Built nx_cc_sovereign -> nxasm_x86 (no gcc, no .sh). license_tier: ORIGINAL 11import "nx_syscalls.nx" 12import "nx_gate_emit_lib.nx" 13import "nx_netquant.nx" 14 15func setf(f: *i64, x: i64, y: i64, z: i64, yaw: i64, pitch: i64, sp: i64, ct: i64, act: i64, anim: i64, fl: i64) -> i64 { 16 f[0]=x; f[1]=y; f[2]=z; f[3]=yaw; f[4]=pitch; f[5]=sp; f[6]=ct; f[7]=act; f[8]=anim; f[9]=fl 17 return 0 18} 19func fcopy(dst: *i64, src: *i64) -> i64 { var i: i64=0; while i<10 { dst[i]=src[i]; i=i+1 } return 0 } 20// equality with the codec's lossy-but-defined fields normalized (yaw mod360, anim low6) 21func feq_full(a: *i64, b: *i64) -> i64 { 22 var i: i64=0 23 while i<10 { 24 var av: i64 = a[i]; var bv: i64 = b[i] 25 if i==3 { av = nq_yawn(av); bv = nq_yawn(bv) } 26 if i==8 { av = av & 63; bv = bv & 63 } 27 if av != bv { return 0 } 28 i=i+1 29 } 30 return 1 31} 32func feq_exact(a: *i64, b: *i64) -> i64 { var i: i64=0; while i<10 { if a[i]!=b[i] { return 0 } i=i+1 } return 1 } 33 34func main() -> i64 { 35 g_puts("nx_netquant gate (sovereign bit-packed/delta state codec for adverse networks)\n" as *u8) 36 var pass: i64 = 0; var total: i64 = 0 37 38 let buf: *u8 = sys_mmap(256) 39 let f: *i64 = sys_mmap(10*8) as *i64 40 let g: *i64 = sys_mmap(10*8) as *i64 41 let base:*i64 = sys_mmap(10*8) as *i64 42 let cur: *i64 = sys_mmap(10*8) as *i64 43 let out: *i64 = sys_mmap(10*8) as *i64 44 45 // a representative player snapshot (z negative -> west of origin) 46 setf(f, 1500, 9, 0-820, 725, 0-37, 2, 6, 4, 41, 1) 47 48 // 1) FULL round-trip + bit measure 49 let fbits: i64 = nq_pack_full(buf, f) 50 nq_unpack_full(buf, g) 51 var r1: i64 = feq_full(f, g) 52 g_puts(" [measure] FULL keyframe = " as *u8); g_pn(fbits); g_puts(" bits = " as *u8); g_pn(nx_bits_bytes(fbits)); g_puts(" bytes (raw frame = 28 bytes)\n" as *u8) 53 pass = pass + g_check("FULL keyframe round-trips exactly" as *u8, r1); total=total+1 54 55 // 2) BIT BUDGET: full < raw 56 pass = pass + g_check("BIT BUDGET: full keyframe < 28-byte raw frame" as *u8, nx_bits_bytes(fbits) < 28); total=total+1 57 58 // 3) DELTA stationary 59 setf(base, 1500, 9, 0-820, 725, 0-37, 2, 6, 4, 41, 1) 60 fcopy(cur, base) // no change 61 let dbits0: i64 = nq_pack_delta(buf, base, cur) 62 nq_unpack_delta(buf, base, out) 63 var r3: i64 = 1 64 if feq_exact(out, cur) != 1 { r3 = 0 } 65 g_puts(" [measure] DELTA stationary = " as *u8); g_pn(dbits0); g_puts(" bits = " as *u8); g_pn(nx_bits_bytes(dbits0)); g_puts(" bytes\n" as *u8) 66 if nx_bits_bytes(dbits0) > 2 { r3 = 0 } // mask-only must be tiny 67 pass = pass + g_check("DELTA stationary tiny + exact" as *u8, r3); total=total+1 68 69 // 4) DELTA small move < FULL, exact 70 fcopy(cur, base); cur[0]=cur[0]+2; cur[2]=cur[2]+1; cur[3]=cur[3]+3 // walk a couple voxels, turn 3deg 71 let dbits1: i64 = nq_pack_delta(buf, base, cur) 72 nq_unpack_delta(buf, base, out) 73 var r4: i64 = 1 74 if feq_exact(out, cur) != 1 { r4 = 0 } 75 if dbits1 >= fbits { r4 = 0 } // delta must beat full for a small move 76 g_puts(" [measure] DELTA small-move = " as *u8); g_pn(dbits1); g_puts(" bits = " as *u8); g_pn(nx_bits_bytes(dbits1)); g_puts(" bytes (< full " as *u8); g_pn(nx_bits_bytes(fbits)); g_puts(")\n" as *u8) 77 pass = pass + g_check("DELTA small-move beats FULL + exact" as *u8, r4); total=total+1 78 79 // 5) WALK PATH: 16 frames, delta-coded vs previous -> avg bytes/snapshot 80 fcopy(base, f) 81 fcopy(cur, f) 82 var totbits: i64 = 0 83 var frame: i64 = 0 84 var walkok: i64 = 1 85 while frame < 16 { 86 cur[0] = cur[0] + 1 // drift east 1 voxel/frame 87 if (frame % 3) == 0 { cur[2] = cur[2] + 1 } // occasional z step 88 cur[3] = cur[3] + 2 // slow turn 89 if (frame % 8) == 0 { cur[8] = cur[8] + 1 } // anim tick 90 let db: i64 = nq_pack_delta(buf, base, cur) 91 nq_unpack_delta(buf, base, out) 92 if feq_exact(out, cur) != 1 { walkok = 0 } 93 totbits = totbits + db 94 fcopy(base, cur) // baseline advances to the just-sent frame 95 frame = frame + 1 96 } 97 let avgbytes: i64 = nx_bits_bytes(totbits) / 16 98 g_puts(" [measure] WALK 16 frames: total " as *u8); g_pn(nx_bits_bytes(totbits)); g_puts(" bytes, avg " as *u8); g_pn(avgbytes); g_puts(" B/snapshot vs full 11 B vs raw 28 B\n" as *u8) 99 if walkok != 1 { } 100 if avgbytes >= 11 { walkok = 0 } // delta walk must beat full keyframes 101 pass = pass + g_check("WALK delta-coded round-trips + beats full keyframes" as *u8, walkok); total=total+1 102 103 // 6) anti-tautology (neg): wrong baseline -> wrong result (delta IS baseline-relative) 104 fcopy(base, f) 105 fcopy(cur, f); cur[0]=cur[0]+5 106 nq_pack_delta(buf, base, cur) 107 let wrong: *i64 = sys_mmap(10*8) as *i64 108 setf(wrong, 999, 9, 0-820, 725, 0-37, 2, 6, 4, 41, 1) // different x baseline 109 nq_unpack_delta(buf, wrong, out) 110 var r6: i64 = 1 111 if feq_exact(out, cur) == 1 { r6 = 0 } // must NOT equal cur (it was decoded vs the wrong base) 112 if out[0] != 999 + 5 { r6 = 0 } // it applied the +5 delta to the wrong base, as expected 113 pass = pass + g_check("anti-tautology: delta is baseline-relative (wrong base -> wrong result)" as *u8, r6); total=total+1 114 115 g_puts("---- netquant gate: passed " as *u8); g_pn(pass); g_puts(" / " as *u8); g_pn(total); g_puts(" ----\n" as *u8) 116 if pass == total { g_puts("verdict=GREEN\n" as *u8); sys_exit(0); return 0 } 117 g_puts("verdict=RED\n" as *u8); sys_exit(1); return 1 118}