code wiki / (root) / nx_nxa_groom_gate.nx
`nx_nxa_groom_gate.nx` source

↩ module page · 369 lines · 14496 B
1// nx_nxa_groom_gate.nx -- THE GROOM GATE v3: anatomical invariants on a generated groom asset.
2//
3// WHY (operator 2026-08-26, twice in one day): first a backwards groom shipped because the referee
4// plot inherited the organ's own facing assumption; then a head-covering wrap shipped because 794
5// permil of synthesized roots sat INSIDE the skull and hair grew out of the volume. Both defects are
6// now BANKED REAL ASSETS and both are teeth here. v2 replaces the v1 facing basis (an extreme-extent
7// nose test, itself refuted: the dense face mesh drags the centroid so the sparse occiput measures
8// the larger extent) with the same basis the groom organ now uses: the estate rig convention
9// ANTERIOR-NEGATIVE = FACE, cross-checked by mesh density, refusing on disagreement.
10// license_tier: ORIGINAL   No hw writes (Rule 26).   expect_exit: 0
11import "nx_syscalls.nx"
12import "nx_gate_verdict.nx"
13
14const GG_SUBJECT: *u8 = "sites/nishifamily/world/ref9d.nxa"
15const GG_FIX_HIJAB: *u8 = "knowledge/banked_ref9d_hijab.nxa"       // real defect 2: face-side roots + interior fill
16const GG_FIX_BACKWARDS: *u8 = "knowledge/banked_ref9d_backwards.nxa" // real defect 1: interior fill (its facing is the correct side)
17const GG_HDR: i64 = 32
18const GG_TOCE: i64 = 32
19const GG_WORDS: i64 = 24
20const GG_PTS: i64 = 8
21const GG_HEADBAND_PERMIL: i64 = 120
22const GG_MIN_STRANDS: i64 = 4800
23const GG_LEN_LO_PERMIL: i64 = 180
24const GG_LEN_HI_PERMIL: i64 = 400
25const GG_CONF_MAX_PERMIL: i64 = 1300
26const GG_FACE_CONE_PERMIL: i64 = 350
27const GG_EYE_DROP_PERMIL: i64 = 40
28const GG_FACE_MAX_PERMIL: i64 = 80
29// ON-SURFACE BY NEAREST NEIGHBOUR. The first draft binned the shell by octant x elevation and was
30// refuted by its own control: REAL surface roots read 764 permil interior, because a bin shared by
31// chin and scalp takes the chin's radius. The exact test for this asset class: distance to the
32// NEAREST head vert. Kept roots ARE verts (NN = 0); an on-shell synthetic sits within its jitter of
33// an anchor; an interior point is far from every vert. The bound is DERIVED per asset as twice the
34// mesh's own median inter-vert spacing -- no constant survives a re-mesh. Measured on the banked
35// wide-blend defect: 290 permil far; real roots 0.
36const GG_FAR_MAX_PERMIL: i64 = 100
37const GG_FAR_FIX_MIN_PERMIL: i64 = 200
38const GG_SPACING_SAMPLES: i64 = 128
39
40func gg_rd64(b: *u8, o: i64) -> i64 {
  var v: i64 = 0
  var k: i64 = 7
  while k >= 0 { v = v*256 + (b[o + k] as i64); k = k - 1 }
  return v
45}
46func gg_tageq(b: *u8, o: i64, t: *u8) -> i64 {
  var i: i64 = 0
  while i < 4 { if b[o + i] != t[i] { return 0 } i = i + 1 }
  return 1
50}
51func gg_isqrt(n: i64) -> i64 {
  if n <= 0 { return 0 }
  var x: i64 = n
  var y: i64 = (x + 1) / 2
  while y < x { x = y; y = (x + n/x) / 2 }
  return x
57}
58
59
60// one pass over an NXA: fills out[0..11] =
61//  ok, antneg, antpos, front_roots, back_roots, nstr, meanlen_permil_of_span,
62//  maxrootdist_permil_of_bandr, facecone_permil, span, far_from_surface_permil, spacing
63func gg_stats(path: *u8, out: *i64) -> i64 {
  out[0] = 0
  let lp: *i64 = sys_mmap(16) as *i64
  let b: *u8 = sys_read_file(path, lp)
  if (b as i64) == 0 { return 0 }
  let ns: i64 = gg_rd64(b, 16)
  if ns < 1 { return 0 }
  var vo: i64 = 0 - 1
  var ho: i64 = 0 - 1
  var s: i64 = 0
  while s < ns {
      let e: i64 = GG_HDR + s*GG_TOCE
      if gg_tageq(b, e, "VERT" as *u8) == 1 { vo = gg_rd64(b, e + 8) }
      if gg_tageq(b, e, "HSTR" as *u8) == 1 { ho = gg_rd64(b, e + 8) }
      s = s + 1
  }
  if vo < 0 { return 0 }
  if ho < 0 { return 0 }
  let nv: i64 = gg_rd64(b, vo)
  let nstr: i64 = gg_rd64(b, ho)
  if nv < 8 { return 0 }
  if nstr < 1 { return 0 }
  var mn0: i64 = 0
  var mx0: i64 = 0
  var mn1: i64 = 0
  var mx1: i64 = 0
  var mn2: i64 = 0
  var mx2: i64 = 0
  var first: i64 = 1
  var i: i64 = 0
  while i < nv {
      let c0: i64 = gg_rd64(b, vo + 8 + (i*3)*8)
      let c1: i64 = gg_rd64(b, vo + 8 + (i*3 + 1)*8)
      let c2: i64 = gg_rd64(b, vo + 8 + (i*3 + 2)*8)
      if first == 1 { mn0 = c0; mx0 = c0; mn1 = c1; mx1 = c1; mn2 = c2; mx2 = c2; first = 0 }
      if c0 < mn0 { mn0 = c0 }
      if c0 > mx0 { mx0 = c0 }
      if c1 < mn1 { mn1 = c1 }
      if c1 > mx1 { mx1 = c1 }
      if c2 < mn2 { mn2 = c2 }
      if c2 > mx2 { mx2 = c2 }
      i = i + 1
  }
  let e0: i64 = mx0 - mn0
  let e1: i64 = mx1 - mn1
  let e2: i64 = mx2 - mn2
  var sa: i64 = 2
  if e0 >= e1 { if e0 >= e2 { sa = 0 } }
  if e1 > e0 { if e1 >= e2 { sa = 1 } }
  var la: i64 = 0
  var aa: i64 = 1
  if sa == 0 { la = 1; aa = 2; if e2 > e1 { la = 2; aa = 1 } }
  if sa == 1 { la = 0; aa = 2; if e2 > e0 { la = 2; aa = 0 } }
  if sa == 2 { la = 0; aa = 1; if e1 > e0 { la = 1; aa = 0 } }
  var span: i64 = e2
  var stop: i64 = mx2
  if sa == 0 { span = e0; stop = mx0 }
  if sa == 1 { span = e1; stop = mx1 }
  if span <= 0 { return 0 }
  let bandlo: i64 = stop - span*GG_HEADBAND_PERMIL/1000
  var hcx: i64 = 0
  var hcy: i64 = 0
  var hcz: i64 = 0
  var hcn: i64 = 0
  i = 0
  while i < nv {
      let pst: i64 = gg_rd64(b, vo + 8 + (i*3 + sa)*8)
      if pst >= bandlo {
          hcx = hcx + gg_rd64(b, vo + 8 + (i*3)*8)
          hcy = hcy + gg_rd64(b, vo + 8 + (i*3 + 1)*8)
          hcz = hcz + gg_rd64(b, vo + 8 + (i*3 + 2)*8)
          hcn = hcn + 1
      }
      i = i + 1
  }
  if hcn < 8 { return 0 }
  let cx: i64 = hcx/hcn
  let cy: i64 = hcy/hcn
  let cz: i64 = hcz/hcn
  // density cross-check + band radius + HEAD-VERT TABLE for the NN surface test
  let hv: *i64 = sys_mmap(hcn*3*8 + 64) as *i64
  var hn: i64 = 0
  var antpos: i64 = 0
  var antneg: i64 = 0
  var bandr: i64 = 0
  i = 0
  while i < nv {
      let pst: i64 = gg_rd64(b, vo + 8 + (i*3 + sa)*8)
      if pst >= bandlo {
          let vx: i64 = gg_rd64(b, vo + 8 + (i*3)*8)
          let vy: i64 = gg_rd64(b, vo + 8 + (i*3 + 1)*8)
          let vz: i64 = gg_rd64(b, vo + 8 + (i*3 + 2)*8)
          let dx: i64 = vx - cx
          let dy: i64 = vy - cy
          let dz: i64 = vz - cz
          var pav: i64 = dz
          if aa == 0 { pav = dx }
          if aa == 1 { pav = dy }
          if pav > 0 { antpos = antpos + 1 } else { antneg = antneg + 1 }
          let rr: i64 = gg_isqrt(dx*dx + dy*dy + dz*dz)
          if rr > bandr { bandr = rr }
          hv[hn*3] = vx
          hv[hn*3 + 1] = vy
          hv[hn*3 + 2] = vz
          hn = hn + 1
      }
      i = i + 1
  }
  if bandr <= 0 { return 0 }
  if hn < 8 { return 0 }
  // median inter-vert spacing from a strided sample: the mesh's own resolution, derived not chosen
  let sstep: i64 = hn/GG_SPACING_SAMPLES + 1
  let samp: *i64 = sys_mmap(GG_SPACING_SAMPLES*8 + 64) as *i64
  var sn9: i64 = 0
  var k9: i64 = 0
  while k9 < hn {
      if sn9 < GG_SPACING_SAMPLES {
          var best: i64 = 0
          var j9: i64 = 0
          while j9 < hn {
              if j9 != k9 {
                  let ddx: i64 = hv[k9*3] - hv[j9*3]
                  let ddy: i64 = hv[k9*3 + 1] - hv[j9*3 + 1]
                  let ddz: i64 = hv[k9*3 + 2] - hv[j9*3 + 2]
                  let d2: i64 = ddx*ddx + ddy*ddy + ddz*ddz
                  if d2 > 0 { if best == 0 { best = d2 } else { if d2 < best { best = d2 } } }
              }
              j9 = j9 + 1
          }
          // insertion into the sorted sample array (no break in this dialect: flag walk)
          let dv: i64 = gg_isqrt(best)
          var p9: i64 = sn9
          var moving: i64 = 1
          while moving == 1 {
              if p9 > 0 {
                  if samp[p9 - 1] > dv { samp[p9] = samp[p9 - 1]; p9 = p9 - 1 } else { moving = 0 }
              } else { moving = 0 }
          }
          samp[p9] = dv
          sn9 = sn9 + 1
      }
      k9 = k9 + sstep
  }
  let spacing: i64 = samp[sn9/2]
  // ORIENTATION BY CONVENTION (anterior-negative = face), the same basis as the groom organ
  let fsign: i64 = 0 - 1
  let eyelvl: i64 = stop - span*GG_EYE_DROP_PERMIL/1000
  var front: i64 = 0
  var back: i64 = 0
  var lensum: i64 = 0
  var maxroot: i64 = 0
  var conepts: i64 = 0
  var totpts: i64 = 0
  var interior: i64 = 0
  var binned: i64 = 0
  var si: i64 = 0
  while si < nstr {
      let base: i64 = ho + 8 + si*GG_WORDS*8
      let rx: i64 = gg_rd64(b, base)
      let ry: i64 = gg_rd64(b, base + 8)
      let rz: i64 = gg_rd64(b, base + 16)
      let rdx: i64 = rx - cx
      let rdy: i64 = ry - cy
      let rdz: i64 = rz - cz
      var rav: i64 = rdz
      if aa == 0 { rav = rdx }
      if aa == 1 { rav = rdy }
      if rav*fsign > 0 { front = front + 1 } else { back = back + 1 }
      let rdist: i64 = gg_isqrt(rdx*rdx + rdy*rdy + rdz*rdz)
      if rdist > maxroot { maxroot = rdist }
      // NN to the head mesh: far from every vert = not on the surface
      var bd2: i64 = 0
      var j8: i64 = 0
      while j8 < hn {
          let ex: i64 = rx - hv[j8*3]
          let ey: i64 = ry - hv[j8*3 + 1]
          let ez: i64 = rz - hv[j8*3 + 2]
          let d28: i64 = ex*ex + ey*ey + ez*ez
          if j8 == 0 { bd2 = d28 } else { if d28 < bd2 { bd2 = d28 } }
          j8 = j8 + 1
      }
      binned = binned + 1
      // bound = 5x median spacing, CALIBRATED ON MEASURED DATA (2026-08-27): a point on a
      // triangle INTERIOR is legitimately ~circumradius from every corner -- barycentric surface
      // roots measure NN p50=379 p99=860 max=941 on ref9d, while the banked interior-fill defect
      // measures p50=1,397. 5x226=1,130 sits between with ~20% margin each way; 2x clipped
      // genuine surface points (measured: it refused a correct barycentric groom at 391 permil).
      if gg_isqrt(bd2) > spacing*5 { interior = interior + 1 }
      var p: i64 = 0
      var slen: i64 = 0
      while p < GG_PTS {
          let px: i64 = gg_rd64(b, base + (p*3)*8)
          let py: i64 = gg_rd64(b, base + (p*3 + 1)*8)
          let pz: i64 = gg_rd64(b, base + (p*3 + 2)*8)
          if p > 0 {
              let qx: i64 = px - gg_rd64(b, base + ((p - 1)*3)*8)
              let qy: i64 = py - gg_rd64(b, base + ((p - 1)*3 + 1)*8)
              let qz: i64 = pz - gg_rd64(b, base + ((p - 1)*3 + 2)*8)
              slen = slen + gg_isqrt(qx*qx + qy*qy + qz*qz)
          }
          let ddx: i64 = px - cx
          let ddy: i64 = py - cy
          let ddz: i64 = pz - cz
          var pant: i64 = ddz
          if aa == 0 { pant = ddx }
          if aa == 1 { pant = ddy }
          let prr: i64 = gg_isqrt(ddx*ddx + ddy*ddy + ddz*ddz)
          var pst9: i64 = pz
          if sa == 0 { pst9 = px }
          if sa == 1 { pst9 = py }
          totpts = totpts + 1
          if pst9 < eyelvl { if prr > 0 { if pant*fsign*1000 > prr*GG_FACE_CONE_PERMIL {
              conepts = conepts + 1
          } } }
          p = p + 1
      }
      lensum = lensum + slen
      si = si + 1
  }
  out[0] = 1
  out[1] = antneg
  out[2] = antpos
  out[3] = front
  out[4] = back
  out[5] = nstr
  out[6] = (lensum/nstr)*1000/span
  out[7] = maxroot*1000/bandr
  out[8] = conepts*1000/totpts
  out[9] = span
  var ib: i64 = binned
  if ib < 1 { ib = 1 }
  out[10] = interior*1000/ib
  out[11] = spacing
  return 1
297}
298
299func gg_dump(tag: *u8, o: *i64) -> i64 {
  gv_puts("  " as *u8); gv_puts(tag)
  gv_puts(": density neg=" as *u8); gv_num(o[1])
  gv_puts(" pos=" as *u8); gv_num(o[2])
  gv_puts(" roots front=" as *u8); gv_num(o[3])
  gv_puts(" back=" as *u8); gv_num(o[4])
  gv_puts(" strands=" as *u8); gv_num(o[5])
  gv_puts(" len_permil=" as *u8); gv_num(o[6])
  gv_puts(" rootmax_permil=" as *u8); gv_num(o[7])
  gv_puts(" facecone_permil=" as *u8); gv_num(o[8])
  gv_puts(" far_permil=" as *u8); gv_num(o[10])
  gv_puts(" spacing=" as *u8); gv_num(o[11])
  gv_puts("\n" as *u8)
  return 0
313}
314
315func main(argc: i64, argv: *i64) -> i64 {
  gv_head("NXA-GROOM-GATE v2 -- anatomical invariants incl the interior-shell (head-wrap) tooth" as *u8)
  let ctr: *i64 = gv_ctr()
  var subj: *u8 = GG_SUBJECT
  if argc > 1 { subj = argv[1] as *u8 }
  let so: *i64 = sys_mmap(128) as *i64
  let ho: *i64 = sys_mmap(128) as *i64
  let bo: *i64 = sys_mmap(128) as *i64
  let sok: i64 = gg_stats(subj, so)
  gv_need("subject-asset-readable" as *u8, sok, ctr)
  if sok == 1 {
      gg_dump("subject" as *u8, so)
      var t0: i64 = 0
      if so[1] > so[2] { t0 = 1 }
      gv_check("orientation-density-agrees-with-convention" as *u8, t0, ctr)
      var t1: i64 = 0
      if so[4] > so[3] { t1 = 1 }
      gv_check("facing-roots-behind-face" as *u8, t1, ctr)
      var t3: i64 = 0
      if so[5] >= GG_MIN_STRANDS { t3 = 1 }
      gv_check("density-floor" as *u8, t3, ctr)
      var t4: i64 = 0
      if so[6] >= GG_LEN_LO_PERMIL { if so[6] <= GG_LEN_HI_PERMIL { t4 = 1 } }
      gv_check("length-band-permil" as *u8, t4, ctr)
      var t5: i64 = 0
      if so[7] <= GG_CONF_MAX_PERMIL { t5 = 1 }
      gv_check("scalp-conformance" as *u8, t5, ctr)
      var t6: i64 = 0
      if so[8] <= GG_FACE_MAX_PERMIL { t6 = 1 }
      gv_check("face-cone-clear" as *u8, t6, ctr)
      var t7: i64 = 0
      if so[10] <= GG_FAR_MAX_PERMIL { t7 = 1 }
      gv_check("roots-near-scalp-surface" as *u8, t7, ctr)
  }
  let hok: i64 = gg_stats(GG_FIX_HIJAB, ho)
  gv_need("hijab-fixture-readable" as *u8, hok, ctr)
  if hok == 1 {
      gg_dump("fix-hijab" as *u8, ho)
      var n1: i64 = 0
      if ho[3] > ho[4] { n1 = 1 }
      gv_check("neg-control-hijab-fails-facing" as *u8, n1, ctr)
      var n2: i64 = 0
      if ho[8] > GG_FACE_MAX_PERMIL { n2 = 1 }
      gv_check("neg-control-hijab-floods-face-cone" as *u8, n2, ctr)
  }
  let bok: i64 = gg_stats(GG_FIX_BACKWARDS, bo)
  gv_need("interior-fixture-readable" as *u8, bok, ctr)
  if bok == 1 {
      gg_dump("fix-interior" as *u8, bo)
      var n3: i64 = 0
      if bo[10] >= GG_FAR_FIX_MIN_PERMIL { n3 = 1 }
      gv_check("neg-control-interior-fill-detected" as *u8, n3, ctr)
  }
  return gv_verdict("NXA-GROOM-GATE" as *u8, ctr, "groom anatomy holds and both banked real defects still fail" as *u8)
369}
nx_nxa_groom_gate.nx source

`nx_nxa_groom_gate.nx` source
