code wiki / _hdl_build / nx_charjudge_gate.nx
`nx_charjudge_gate.nx` source

↩ module page · 404 lines · 18460 B
1// nx_charjudge_gate.nx -- the LIAR-KILLER battery for the v2 character judge, all fixtures SYNTHETIC +
2// deterministic (no file deps): a composed "character" (smooth bg + textured figure + border contours +
3// face patch with an eye pair), its eyeless twin, a flat blob, an aligned-16px patch-scramble of the
4// composed image, and the smooth+noise+palette COLLAGE that games v1. Teeth assert the HUMAN ordering,
5// per-axis kills, determinism, and the conf override path. Designing this battery already killed two
6// contour-axis designs before they shipped (plain run-length: dense noise is fully connected; scramble
7// seams are long lines) -- that is the gate doing its job at design time. license_tier: ORIGINAL  expect_exit: 0
8import "nx_syscalls.nx"
9import "nx_charjudge_lib.nx"
10import "nx_gate_verdict.nx"
11const CHG_W: i64 = 256
12const CHG_H: i64 = 256
13const CHG_LCG_A: i64 = 1103515245
14const CHG_LCG_C: i64 = 12345
15const CHG_LCG_M: i64 = 2147483647
16// ★A SECOND RESOLUTION. Every tooth in this battery ran at 256x256 -- which is EXACTLY ref_w, the width the
17// eye geometry was calibrated at, where the scale factor is 1.0 and the pyramid is irrelevant. Both defects
18// found on 2026-08-15 lived entirely outside this single resolution, which is how 8/8 GREEN coexisted with a
19// judge that scored an actual face close-up 0 and a faceless voxel landscape 1000. A battery that has only
20// ever seen one resolution cannot report on a scale bug, and its greenness is not evidence about one.
21const CHG_W2: i64 = 512
22const CHG_H2: i64 = 512
23
24func gw(s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(1,s,n); return 0 }
25func gn(v: i64) -> i64 {
  let b: *u8 = sys_mmap(32)
  var x: i64 = v; var ng: i64 = 0
  if x < 0 { ng = 1; x = 0-x }
  var i: i64 = 31
  if x == 0 { b[i]=48 as u8; i=i-1 }
  while x > 0 { b[i]=(48+x%10) as u8; x=x/10; i=i-1 }
  if ng == 1 { b[i]=45 as u8; i=i-1 }
  sys_write(1,(b as i64+i+1) as *u8,31-i)
  return 0
35}
36func chg_px(r: i64, g: i64, b: i64) -> i64 {
  var r2: i64 = r
  var g2: i64 = g
  var b2: i64 = b
  if r2 < 0 { r2 = 0 }
  if r2 > 255 { r2 = 255 }
  if g2 < 0 { g2 = 0 }
  if g2 > 255 { g2 = 255 }
  if b2 < 0 { b2 = 0 }
  if b2 > 255 { b2 = 255 }
  return r2 + g2*256 + b2*CHJ_MAGIC_65536
47}
48// composed character fixture. eyes=1 draws the eye pair.
49func chg_composed(fb: *i64, eyes: i64) -> i64 {
  var s: i64 = 777
  var y: i64 = 0
  while y < CHG_H {
      var x: i64 = 0
      while x < CHG_W {
          fb[y*CHG_W+x] = chg_px(40 + y, 80 + y/2, 250 - y/2)
          x = x + 1
      }
      y = y + 1
  }
  y = 48
  while y < 224 {
      var x: i64 = 64
      while x < 192 {
          s = (s*CHG_LCG_A + CHG_LCG_C) & CHG_LCG_M
          let nz: i64 = (s>>15) % 51 - 25
          fb[y*CHG_W+x] = chg_px(60 + y%128 + nz, 50 + (x+y)%150 + nz, 90 + x%120 + nz)
          x = x + 1
      }
      y = y + 1
  }
  // face patch (flat skin) so the eyes are the only compact dark blobs there
  y = 64
  while y < 120 {
      var x: i64 = 96
      while x < 176 {
          fb[y*CHG_W+x] = chg_px(230, 200, 180)
          x = x + 1
      }
      y = y + 1
  }
  if eyes == 1 {
      var ey: i64 = 0-3
      while ey <= 3 {
          var ex: i64 = 0-3
          while ex <= 3 {
              if ex*ex + ey*ey <= 9 {
                  fb[(89+ey)*CHG_W + 113+ex] = chg_px(25, 20, 20)
                  fb[(89+ey)*CHG_W + 145+ex] = chg_px(25, 20, 20)
              }
              ex = ex + 1
          }
          ey = ey + 1
      }
  }
  // 2px dark border = the long contours
  y = 48
  while y < 224 {
      fb[y*CHG_W+64] = chg_px(30,30,40)
      fb[y*CHG_W+65] = chg_px(30,30,40)
      fb[y*CHG_W+190] = chg_px(30,30,40)
      fb[y*CHG_W+191] = chg_px(30,30,40)
      y = y + 1
  }
  var x5: i64 = 64
  while x5 < 192 {
      fb[48*CHG_W+x5] = chg_px(30,30,40)
      fb[49*CHG_W+x5] = chg_px(30,30,40)
      fb[222*CHG_W+x5] = chg_px(30,30,40)
      fb[223*CHG_W+x5] = chg_px(30,30,40)
      x5 = x5 + 1
  }
  return 0
113}
114func chg_blob(fb: *i64) -> i64 {
  var y: i64 = 0
  while y < CHG_H {
      var x: i64 = 0
      while x < CHG_W {
          fb[y*CHG_W+x] = chg_px(40 + y, 80 + y/2, 250 - y/2)
          x = x + 1
      }
      y = y + 1
  }
  y = 48
  while y < 224 {
      var x: i64 = 64
      while x < 192 {
          fb[y*CHG_W+x] = chg_px(200, 170, 150)
          x = x + 1
      }
      y = y + 1
  }
  y = 48
  while y < 224 {
      fb[y*CHG_W+64] = chg_px(30,30,40)
      fb[y*CHG_W+191] = chg_px(30,30,40)
      y = y + 1
  }
  var x6: i64 = 64
  while x6 < 192 {
      fb[48*CHG_W+x6] = chg_px(30,30,40)
      fb[223*CHG_W+x6] = chg_px(30,30,40)
      x6 = x6 + 1
  }
  return 0
146}
147func chg_scramble(src: *i64, dst: *i64) -> i64 {
  let P: i64 = 16
  let nx: i64 = CHG_W/P
  let ny: i64 = CHG_H/P
  let n: i64 = nx*ny
  let perm: *i64 = sys_mmap(n*8) as *i64
  var i: i64 = 0
  while i < n { perm[i] = i; i = i + 1 }
  var s: i64 = 80404
  i = n - 1
  while i > 0 {
      s = (s*CHG_LCG_A + CHG_LCG_C) & CHG_LCG_M
      let j: i64 = s % (i+1)
      let t: i64 = perm[i]; perm[i] = perm[j]; perm[j] = t
      i = i - 1
  }
  i = 0
  while i < n {
      let src2: i64 = perm[i]
      let dx: i64 = (i%nx)*P
      let dy: i64 = (i/nx)*P
      let sx: i64 = (src2%nx)*P
      let sy: i64 = (src2/nx)*P
      var yy: i64 = 0
      while yy < P {
          var xx: i64 = 0
          while xx < P { dst[(dy+yy)*CHG_W + dx+xx] = src[(sy+yy)*CHG_W + sx+xx]; xx = xx + 1 }
          yy = yy + 1
      }
      i = i + 1
  }
  return 0
179}
180func chg_collage(fb: *i64) -> i64 {
  var s: i64 = 4242
  var y: i64 = 0
  while y < CHG_H {
      var x: i64 = 0
      while x < CHG_W {
          if x < CHG_W/2 { fb[y*CHG_W+x] = chg_px(120, 140, 160) }
          if x >= CHG_W/2 {
              // high bits: an LCG's LOW bits have period 2^k -- s%256 gave PERIODIC stripes, i.e.
              // real coherent contours, and the "noise" collage wasn't noise (gate T4 caught it)
              s = (s*CHG_LCG_A + CHG_LCG_C) & CHG_LCG_M
              let r: i64 = (s>>15) % 256
              s = (s*CHG_LCG_A + CHG_LCG_C) & CHG_LCG_M
              let g: i64 = (s>>15) % 256
              s = (s*CHG_LCG_A + CHG_LCG_C) & CHG_LCG_M
              let b: i64 = (s>>15) % 256
              fb[y*CHG_W+x] = chg_px(r, g, b)
          }
          x = x + 1
      }
      y = y + 1
  }
  return 0
203}
204// nearest-neighbour 2x upscale: the SAME subject, twice the width. Nearest-neighbour on purpose -- it adds
205// no new detail, so any score change is the judge reacting to size rather than to content.
206func chg_upscale2(src: *i64, dst: *i64) -> i64 {
  var y: i64 = 0
  while y < CHG_H2 {
      var x: i64 = 0
      while x < CHG_W2 {
          dst[y*CHG_W2+x] = src[(y/2)*CHG_W + x/2]
          x = x + 1
      }
      y = y + 1
  }
  return 0
217}
218// the blob fixture with SURFACE TEXTURE laid over the figure, inside its border. This is the case the
219// contour axis inverted on: two real A/B pairs of the same body measured an 8.9x and 6.8x drop in the
220// headline purely for having been textured.
221func chg_textured_blob(fb: *i64) -> i64 {
  chg_blob(fb)
  var s: i64 = 9091
  var y: i64 = 49
  while y < 223 {
      var x: i64 = 65
      while x < 191 {
          s = (s*CHG_LCG_A + CHG_LCG_C) & CHG_LCG_M
          let nz: i64 = (s>>15) % 61 - 30
          fb[y*CHG_W+x] = chg_px(200+nz, 170+nz, 150+nz)
          x = x + 1
      }
      y = y + 1
  }
  return 0
236}
237// NEGATIVE CONTROL for the smoothing change. Same texture, but NO figure and NO border contours. Smoothing
238// before edge extraction must not turn "has texture" into "has contours": if the fix were achieved by making
239// the axis permissive rather than by making it correct, this fixture would rise with the textured blob and
240// this tooth is what says so.
241func chg_texture_only(fb: *i64) -> i64 {
  var s: i64 = 5150
  var y: i64 = 0
  while y < CHG_H {
      var x: i64 = 0
      while x < CHG_W {
          s = (s*CHG_LCG_A + CHG_LCG_C) & CHG_LCG_M
          let nz: i64 = (s>>15) % 61 - 30
          fb[y*CHG_W+x] = chg_px(200+nz, 170+nz, 150+nz)
          x = x + 1
      }
      y = y + 1
  }
  return 0
255}
256// ★MIGRATED ONTO THE BASE CLASS 2026-08-15. This gate hand-rolled its own PASS/FAIL printer and its own
257// failure counter -- the D001 debt: declared and executed tooth counts were two independent numbers, so a
258// tooth that silently stopped running lowered BOTH and the gate still read green. gv_check increments the
259// denominator itself, so declared == executed BY CONSTRUCTION, and gv_verdict carries the result in the
260// EXIT CODE -- without which /api/gate_run derives its verdict from a passing exit and serves a RED gate as
261// GREEN. The build lane refused this file until it emitted that anchor, and it was right to.
262
263func main() -> i64 {
  gw("=== nx_charjudge_gate -- liar-killer battery for the v2 character judge ===\n" as *u8)
  let ctr: *i64 = gv_ctr()
  let npx: i64 = CHG_W*CHG_H
  let fA: *i64 = sys_mmap(npx*8) as *i64
  let fB: *i64 = sys_mmap(npx*8) as *i64
  let fS: *i64 = sys_mmap(npx*8) as *i64
  let fC: *i64 = sys_mmap(npx*8) as *i64
  let fE: *i64 = sys_mmap(npx*8) as *i64
  chg_composed(fA, 1)
  chg_blob(fB)
  chg_scramble(fA, fS)
  chg_collage(fC)
  chg_composed(fE, 0)
  let oA: *i64 = sys_mmap(CHJ_NOUT*8) as *i64
  let oA2: *i64 = sys_mmap(CHJ_NOUT*8) as *i64
  let oB: *i64 = sys_mmap(CHJ_NOUT*8) as *i64
  let oS: *i64 = sys_mmap(CHJ_NOUT*8) as *i64
  let oC: *i64 = sys_mmap(CHJ_NOUT*8) as *i64
  let oE: *i64 = sys_mmap(CHJ_NOUT*8) as *i64
  // HERMETIC CONF. This battery's own header promised "all fixtures SYNTHETIC + deterministic (no file
  // deps)" and then read the PRODUCTION conf, so every tooth silently depended on a file another lane
  // edits -- and today that file legitimately changed face_required, which would have turned two teeth red
  // for a reason having nothing to do with the code. It writes its own conf now: face_required=1 so the
  // detector is genuinely exercised here, every other value from the code defaults.
  let gfd: i64 = sys_openat_wr("/tmp/chj_gate.conf" as *u8, MODE_0644)
  let gstr: *u8 = "face_required=1\n" as *u8
  var gcn: i64 = 0
  while gstr[gcn] != (0 as u8) { gcn = gcn + 1 }
  sys_write(gfd, gstr, gcn)
  sys_close(gfd)
  let cp: *u8 = "/tmp/chj_gate.conf" as *u8
  chj_judge(fA, CHG_W, CHG_H, cp, oA)
  chj_judge(fA, CHG_W, CHG_H, cp, oA2)
  chj_judge(fB, CHG_W, CHG_H, cp, oB)
  chj_judge(fS, CHG_W, CHG_H, cp, oS)
  chj_judge(fC, CHG_W, CHG_H, cp, oC)
  chj_judge(fE, CHG_W, CHG_H, cp, oE)
  let fU: *i64 = sys_mmap(CHG_W2*CHG_H2*8) as *i64
  let fT: *i64 = sys_mmap(npx*8) as *i64
  let fTO: *i64 = sys_mmap(npx*8) as *i64
  chg_upscale2(fA, fU)
  chg_textured_blob(fT)
  chg_texture_only(fTO)
  let oU: *i64 = sys_mmap(CHJ_NOUT*8) as *i64
  let oT: *i64 = sys_mmap(CHJ_NOUT*8) as *i64
  let oTO: *i64 = sys_mmap(CHJ_NOUT*8) as *i64
  chj_judge(fU, CHG_W2, CHG_H2, cp, oU)
  chj_judge(fT, CHG_W, CHG_H, cp, oT)
  chj_judge(fTO, CHG_W, CHG_H, cp, oTO)
  gw("composed: head=" as *u8); gn(oA[4]); gw(" comp=" as *u8); gn(oA[0]); gw(" pal=" as *u8); gn(oA[1]); gw(" con=" as *u8); gn(oA[2]); gw(" face=" as *u8); gn(oA[3]); gw("\n" as *u8)
  gw("blob:     head=" as *u8); gn(oB[4]); gw(" comp=" as *u8); gn(oB[0]); gw(" face=" as *u8); gn(oB[3]); gw("\n" as *u8)
  gw("scramble: head=" as *u8); gn(oS[4]); gw(" comp=" as *u8); gn(oS[0]); gw(" con=" as *u8); gn(oS[2]); gw("\n" as *u8)
  gw("collage:  head=" as *u8); gn(oC[4]); gw(" comp=" as *u8); gn(oC[0]); gw(" con=" as *u8); gn(oC[2]); gw("\n" as *u8)
  gw("eyeless:  head=" as *u8); gn(oE[4]); gw(" face=" as *u8); gn(oE[3]); gw("\n" as *u8)
  var t: i64 = 0
  if oA[4] >= 600 { t = 1 }
  gv_check("T1 composed character scores >= 600" as *u8, t, ctr)
  t = 0
  if oB[3] == 0 { if oB[4] == 0 { t = 1 } }
  gv_check("T2 faceless flat blob floors to 0 (face axis)" as *u8, t, ctr)
  // a 16px-grid scramble GENUINELY contains long straight seam lines, so contour cannot floor it to
  // zero -- the honest claim is a deep drop below the composed original (real-content scrambles
  // measured 20/1000 on the kk portrait; this synthetic bg has gentler seams)
  t = 0
  if oS[4] < 300 { if oS[4]*3 < oA[4] { t = 1 } }
  gv_check("T3 16px scramble drops below 300 and below composed/3" as *u8, t, ctr)
  t = 0
  if oC[2] < 100 { if oC[4] < 100 { t = 1 } }
  gv_check("T4 smooth+noise+palette collage floors (contour kills the v1 gameable vector)" as *u8, t, ctr)
  t = 0
  if oE[3] == 0 { if oE[4] == 0 { if oA[3] == 1000 { t = 1 } } }
  gv_check("T5 face axis isolated: eyeless twin 0, eyed twin 1000" as *u8, t, ctr)
  t = 0
  if oA[4] == oA2[4] { t = 1 }
  gv_check("T6 deterministic (same fixture twice, same headline)" as *u8, t, ctr)
  // T7: conf override path -- face_required=0 lifts the eyeless twin off the floor
  let cfd: i64 = sys_openat_wr("/tmp/chj_face_off.conf" as *u8, 0x1a4)
  let cstr: *u8 = "face_required=0\n" as *u8
  var cn: i64 = 0
  while cstr[cn] != (0 as u8) { cn = cn + 1 }
  sys_write(cfd, cstr, cn)
  sys_close(cfd)
  let oE2: *i64 = sys_mmap(CHJ_NOUT*8) as *i64
  chj_judge(fE, CHG_W, CHG_H, "/tmp/chj_face_off.conf" as *u8, oE2)
  t = 0
  if oE2[4] > 0 { t = 1 }
  gv_check("T7 conf override proven live (face_required=0 lifts the eyeless twin)" as *u8, t, ctr)
  t = 0
  if oA[4] > oB[4] { if oA[4] > oS[4] { if oA[4] > oC[4] { t = 1 } } }
  gv_check("T8 strict ordering: composed above blob, scramble, collage" as *u8, t, ctr)
  // PRINT THE VALUES, NOT JUST PASS/FAIL. Both defects fixed on 2026-08-15 were found in a diagnostic
  // dump and never in a verdict vector; a tooth that reports only a boolean cannot say why it moved.
  gw("upscale2x: head=" as *u8); gn(oU[4]); gw(" face=" as *u8); gn(oU[3]); gw(" lv=" as *u8); gn(oU[10]); gw(" cands=" as *u8); gn(oU[11]); gw("\n" as *u8)
  gw("blob_plain: con=" as *u8); gn(oB[2]); gw(" coh=" as *u8); gn(oB[8]); gw(" edges=" as *u8); gn(oB[9]); gw("\n" as *u8)
  gw("blob_tex:   con=" as *u8); gn(oT[2]); gw(" coh=" as *u8); gn(oT[8]); gw(" edges=" as *u8); gn(oT[9]); gw("\n" as *u8)
  gw("tex_only:   con=" as *u8); gn(oTO[2]); gw(" coh=" as *u8); gn(oTO[8]); gw(" edges=" as *u8); gn(oTO[9]); gw("\n" as *u8)
  // T9 -- THE SCALE DEFECT. The same subject at twice the width. The probe radius was scaled by the
  // CURRENT pyramid level's width, so it shrank in lockstep with the image the pyramid was halving and
  // every level re-ran an identical scan: a face larger than the calibration frame was unreachable at
  // any depth. Asserting BOTH twins pins the claim to scale rather than to the fixture.
  t = 0
  if oU[3] == 1000 { if oA[3] == 1000 { t = 1 } }
  gv_check("T9 scale invariance: the SAME composed character at 2x width still scores face 1000" as *u8, t, ctr)
  // T10 -- THE TEXTURE INVERSION, the defect that made this judge unusable as a referee: it graded the
  // estate's own shipped PBR skin bake as a large regression. The bar is a RATIO of the untextured twin
  // rather than an absolute number, so it stays meaningful if the fixtures are ever retuned.
  // T10 -- THE TEXTURE INVERSION, as a BITE-PROVEN cell rather than as two independent booleans. A pass
  // requires BOTH directions at once: the axis must still FIRE on a genuinely contourless texture field
  // AND stay silent on a textured figure that really does have contours. Two separate teeth could each be
  // satisfied by an axis that simply became permissive; only the paired form proves DISCRIMINATION.
  var tbad: i64 = 0
  if oTO[2] < 100 { tbad = 1 }
  var tgood: i64 = 0
  if oT[2]*2 < oB[2] { tgood = 1 }
  gv_bite("T10 neg-control-texture: contour floors a contourless texture field but NOT a textured figure" as *u8, tbad, tgood, ctr)
  // T11 -- THE DEMOTION IS REAL AND COMPLETE. Under the PRODUCTION conf (face_required=0) the composed
  // character and its eyeless twin must score the SAME nonzero headline. If they differ, the face axis is
  // still leaking into the verdict and the demotion is cosmetic; if it is zero, the headline collapsed for
  // some other reason. This is the tooth that catches a future seat re-arming an uncalibrated axis.
  let oPA: *i64 = sys_mmap(CHJ_NOUT*8) as *i64
  let oPE: *i64 = sys_mmap(CHJ_NOUT*8) as *i64
  chj_judge(fA, CHG_W, CHG_H, "knowledge/charjudge.conf" as *u8, oPA)
  chj_judge(fE, CHG_W, CHG_H, "knowledge/charjudge.conf" as *u8, oPE)
  gw("prod_conf: composed_head=" as *u8); gn(oPA[4]); gw(" eyeless_head=" as *u8); gn(oPE[4]); gw(" face_reported=" as *u8); gn(oPA[3]); gw("\n" as *u8)
  // The first form of this tooth asserted the two headlines were EQUAL and failed 986 vs 963 -- correctly,
  // because the eyeless twin is a DIFFERENT IMAGE and its composition, palette and contour legitimately
  // differ. Equality was never the property. The property is that the face axis, while still computed and
  // still reporting 0 on this fixture, no longer selects the minimum.
  t = 0
  var pmin: i64 = oPE[0]
  if oPE[1] < pmin { pmin = oPE[1] }
  if oPE[2] < pmin { pmin = oPE[2] }
  if oPE[4] == pmin { if oPE[4] > 0 { if oPE[3] == 0 { t = 1 } } }
  gv_check("T11 face axis demoted in production: eyeless twin scores MIN(comp,pal,contour), nonzero, with face still computed and reported as 0" as *u8, t, ctr)
  // The count is no longer hand-recited. "GREEN 11/11" was a second, independently-authored number beside
  // the counter that actually ran -- the duplicate-ruler defect, and the reason a gate can print a total
  // it never reached. gv_verdict prints the counter it incremented.
  let rc: i64 = gv_verdict("CHARJUDGE-GATE" as *u8, ctr, "v2 character judge -- composition x palette x contour x face, with the 2026-08-15 texture-inversion and scale-cancellation fixes each under a named negative control" as *u8)
  sys_exit(rc)
  return rc
404}
nx_charjudge_gate.nx source

`nx_charjudge_gate.nx` source
