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

↩ module page · 611 lines · 27963 B
1// _t4_first_model_authored.nx -- T4 of the training-substrate ladder: the FIRST REAL MODEL.
2// Composes the GATED T6/T5 core (nx_tgrad_core.nx, extracted verbatim from _tensor_grad_authored.nx)
3// into two trained models, all bits-up sovereign f32, zero randomness:
4//   LANE 1 (nonconvex proof): XOR via a 2-4-1 relu MLP + AdamW, deterministic symmetry-breaking
5//     init (the zero-init relu trap documented at T6 is closed by a FIXED pattern table, not RNG --
6//     gate-proven here; the principled-init research row stays open in the roadmap).
7//   LANE 2 (REAL TEAM DATA): 8-way service-class model on the ACTUAL elder census
8//     (knowledge/status/elder_census.log) -- first 6 name bytes -> {svc,gen,data,orch,worker,mon,util,other}.
9//     PARSE ORACLE: the census file carries its own ground truth (CENSUS-SUM per-class counts);
10//     the parsed+deduped dataset must match it EXACTLY before training is even attempted.
11// GATES: O census-parse==CENSUS-SUM oracle | G XOR learned (loss<1/100, 4/4 preds within 1/4)
12//        | H census train accuracy == services (100%, per-class pred counts == ground truth)
13//        | I BIT-EXACT two-run training, BOTH lanes (the standing EXCEED axis).
14// Evidence: loss curve + verdicts appended to knowledge/status/modelwright.log (MODELWRIGHT rows
15// = the role's first durable evidence; the scorecard reads this file).
16// LAWS: struct-free, flat ifs, no &&/||, no unary-minus literals, no randomness. license_tier: ORIGINAL
17import "nx_tgrad_core.nx"
18
19const T4_XOR_EPOCHS: i64 = 1500
20const T4_CEN_EPOCHS: i64 = 1500
21const T4_LOG_EVERY: i64 = 100
22const T4_HID: i64 = 24
23const T4_INB: i64 = 8
24const T4_NCLS: i64 = 8
25const T4_MAXSVC: i64 = 200
26
27// write s / decimal v to an fd (durable log helpers; _tg_puts/_tg_num from the core cover stdout)
28func t4_fp(fd: i64, s: *u8) -> i64 { var n: i64=0; while s[n]!=(0 as u8){n=n+1} sys_write(fd,s,n); return 0 }
29func t4_fn(fd: i64, v: i64) -> i64 { let bb: *u8=sys_mmap(28); var m: i64=v; if m<0{m=0-m;sys_write(fd,"-" as *u8,1)}; 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(fd,bb,k); return 0 }
30// both stdout and the durable log
31func t4_bp(fd: i64, s: *u8) -> i64 { _tg_puts(s); t4_fp(fd, s); return 0 }
32func t4_bn(fd: i64, v: i64) -> i64 { _tg_num(v); t4_fn(fd, v); return 0 }
33
34// deterministic symmetry-breaking init: p[i] = (((salt + i*7) mod 13) - 6) / den
35// fixed pattern, varied signs/magnitudes, same bits every run by construction
36func t4_init(p: *i64, n: i64, salt: i64, den: i64) -> i64 {
  var i: i64 = 0
  while i < n {
      let m: i64 = ((salt + i*7) % 13) - 6
      if m < 0 { p[i] = nx_f32_neg(tg_q(0 - m, den)) } else { p[i] = tg_q(m, den) }
      i = i + 1
  }
  return 0
44}
45
46// does buffer b at i match literal lit (lit NUL-terminated, b bounded by n)?
47func t4_match(b: *u8, i: i64, n: i64, lit: *u8) -> i64 {
  var k: i64 = 0
  while lit[k] != (0 as u8) {
      if i + k >= n { return 0 }
      if b[i+k] != lit[k] { return 0 }
      k = k + 1
  }
  return 1
55}
56// token at [i, le) equals lit exactly (delimiter = space or end-of-line)?
57func t4_tokeq(b: *u8, i: i64, le: i64, lit: *u8) -> i64 {
  var k: i64 = 0
  while lit[k] != (0 as u8) {
      if i + k >= le { return 0 }
      if b[i+k] != lit[k] { return 0 }
      k = k + 1
  }
  if i + k == le { return 1 }
  if b[i+k] == (32 as u8) { return 1 }
  return 0
67}
68// parse the unsigned int right after key= inside [ls, le); 0-1 if absent
69func t4_keynum(b: *u8, ls: i64, le: i64, key: *u8) -> i64 {
  var i: i64 = ls
  while i < le {
      if t4_match(b, i, le, key) == 1 {
          var k: i64 = 0
          while key[k] != (0 as u8) { k = k + 1 }
          var j: i64 = i + k
          var v: i64 = 0
          var got: i64 = 0
          while j < le {
              let c: i64 = b[j] as i64
              if c < 48 { j = le } else { if c > 57 { j = le } else { v = v*10 + (c - 48); got = 1; j = j + 1 } }
          }
          if got == 1 { return v }
      }
      i = i + 1
  }
  return 0 - 1
87}
88func t4_classid(b: *u8, i: i64, le: i64) -> i64 {
  if t4_tokeq(b, i, le, "svc" as *u8) == 1 { return 0 }
  if t4_tokeq(b, i, le, "gen" as *u8) == 1 { return 1 }
  if t4_tokeq(b, i, le, "data" as *u8) == 1 { return 2 }
  if t4_tokeq(b, i, le, "orch" as *u8) == 1 { return 3 }
  if t4_tokeq(b, i, le, "worker" as *u8) == 1 { return 4 }
  if t4_tokeq(b, i, le, "mon" as *u8) == 1 { return 5 }
  if t4_tokeq(b, i, le, "util" as *u8) == 1 { return 6 }
  if t4_tokeq(b, i, le, "other" as *u8) == 1 { return 7 }
  return 0 - 1
98}
99func t4_nameq(a: *u8, b: *u8) -> i64 {
  var i: i64 = 0
  while a[i] != (0 as u8) {
      if a[i] != b[i] { return 0 }
      i = i + 1
  }
  if b[i] == (0 as u8) { return 1 }
  return 0
107}
108
109// parse census: dedup by name; names = T4_MAXSVC x 24 bytes; labels per unique svc.
110// sums = 9 cells: per-class ground truth from the LAST CENSUS-SUM line + [8]=services.
111// returns unique count; 0-1 on read failure
112func t4_parse(cpath: *u8, names: *u8, labels: *i64, sums: *i64) -> i64 {
  let lenp: *i64 = sys_mmap(16) as *i64
  let b: *u8 = sys_read_file(cpath, lenp)
  let n: i64 = lenp[0]
  if n <= 0 { return 0 - 1 }
  var cnt: i64 = 0
  var ls: i64 = 0
  while ls < n {
      var le: i64 = ls
      var stop: i64 = 0
      while stop == 0 {
          if le >= n { stop = 1 } else { if b[le] == (10 as u8) { stop = 1 } else { le = le + 1 } }
      }
      let realle: i64 = le
      if t4_match(b, ls, realle, "CENSUS-SVC name=" as *u8) == 1 {
          let ni: i64 = ls + 16
          var ne: i64 = ni
          var stop2: i64 = 0
          while stop2 == 0 {
              if ne >= realle { stop2 = 1 } else { if b[ne] == (32 as u8) { stop2 = 1 } else { ne = ne + 1 } }
          }
          var ci: i64 = 0 - 1
          var j: i64 = ni
          while j < realle {
              if t4_match(b, j, realle, "class=" as *u8) == 1 { ci = t4_classid(b, j + 6, realle); j = realle } else { j = j + 1 }
          }
          var nlen: i64 = ne - ni
          if nlen > 23 { nlen = 23 }
          let tmp: *u8 = sys_mmap(32)
          var k: i64 = 0
          while k < nlen { tmp[k] = b[ni+k]; k = k + 1 }
          tmp[nlen] = 0 as u8
          if ci >= 0 {
              var seen: i64 = 0
              var s: i64 = 0
              while s < cnt {
                  let np: *u8 = (names as i64 + s*24) as *u8
                  if t4_nameq(tmp, np) == 1 { seen = 1; s = cnt } else { s = s + 1 }
              }
              if seen == 0 {
                  if cnt < T4_MAXSVC {
                      let dst: *u8 = (names as i64 + cnt*24) as *u8
                      k = 0
                      while k <= nlen { dst[k] = tmp[k]; k = k + 1 }
                      labels[cnt] = ci
                      cnt = cnt + 1
                  }
              }
          }
      }
      if t4_match(b, ls, realle, "CENSUS-SUM " as *u8) == 1 {
          sums[0] = t4_keynum(b, ls, realle, "svc=" as *u8)
          sums[1] = t4_keynum(b, ls, realle, "gen=" as *u8)
          sums[2] = t4_keynum(b, ls, realle, "data=" as *u8)
          sums[3] = t4_keynum(b, ls, realle, "orch=" as *u8)
          sums[4] = t4_keynum(b, ls, realle, "worker=" as *u8)
          sums[5] = t4_keynum(b, ls, realle, "mon=" as *u8)
          sums[6] = t4_keynum(b, ls, realle, "util=" as *u8)
          sums[7] = t4_keynum(b, ls, realle, "other=" as *u8)
          sums[8] = t4_keynum(b, ls, realle, "services=" as *u8)
      }
      ls = le + 1
  }
  return cnt
176}
177
178// features: first T4_INB name bytes CENTERED, (byte-84)/32 (~[-1.2,1.2] for ASCII names;
179// pad past NUL = the same transform of 0 = a distinctive length signal). Centering matters:
180// the first build used raw byte/64 (all-positive inputs) and plateaued -- positive-orthant
181// features kill relu units dead and the loss froze at 43-84 milli across THREE optimizers.
182// targets: one-hot over T4_NCLS
183func t4_featurize(names: *u8, labels: *i64, cnt: i64, xs: *i64, ts: *i64) -> i64 {
  var s: i64 = 0
  while s < cnt {
      let np: *u8 = (names as i64 + s*24) as *u8
      var j: i64 = 0
      var done: i64 = 0
      while j < T4_INB {
          var byv: i64 = 0
          if done == 0 {
              byv = np[j] as i64
              if byv == 0 { done = 1; byv = 0 }
          }
          let m: i64 = byv - 84
          if m < 0 { xs[s*T4_INB + j] = nx_f32_neg(tg_q(0 - m, 32)) } else { xs[s*T4_INB + j] = tg_q(m, 32) }
          j = j + 1
      }
      var c: i64 = 0
      while c < T4_NCLS {
          if c == labels[s] { ts[s*T4_NCLS + c] = nx_i32_to_f32(1) } else { ts[s*T4_NCLS + c] = 0 }
          c = c + 1
      }
      s = s + 1
  }
  return 0
207}
208
209// census weight layout offsets (one source of truth): w1[0..w1n) b1[b1o..w2o) w2[w2o..b2o) b2[b2o..tot)
210func t4_w1n() -> i64 { return T4_HID * T4_INB }
211func t4_b1o() -> i64 { return t4_w1n() }
212func t4_w2o() -> i64 { return t4_w1n() + T4_HID }
213func t4_b2o() -> i64 { return t4_w2o() + T4_NCLS * T4_HID }
214func t4_tot() -> i64 { return t4_b2o() + T4_NCLS }
215
216// census model plain forward into out8; returns argmax class
217func t4_cen_fwd(w: *i64, x: *i64, out8: *i64) -> i64 {
  let h: *i64 = sys_mmap(256) as *i64
  var i: i64 = 0
  while i < T4_HID {
      var s: i64 = w[t4_b1o() + i]
      var j: i64 = 0
      while j < T4_INB { s = nx_f32_add(s, nx_f32_mul(w[i*T4_INB + j], x[j])); j = j + 1 }
      if nx_f32_lt(s, 0) == 1 { s = 0 }
      h[i] = s
      i = i + 1
  }
  var c: i64 = 0
  var best: i64 = 0
  while c < T4_NCLS {
      var o: i64 = w[t4_b2o() + c]
      i = 0
      while i < T4_HID { o = nx_f32_add(o, nx_f32_mul(w[t4_w2o() + c*T4_HID + i], h[i])); i = i + 1 }
      out8[c] = o
      if c > 0 { if nx_f32_gt(o, out8[best]) == 1 { best = c } }
      c = c + 1
  }
  return best
239}
240
241// train the census MLP (layout from t4_w1n/b1o/w2o/b2o):
242// FULL-BATCH gradient accumulation (per-sample tapes, grads summed over all services) + ONE
243// gated ad_step per epoch, with INVERSE-FREQUENCY CLASS WEIGHTS (wts[s] = (1/NCLS)/hist[label_s],
244// computed from the parsed histogram -- data-driven, no magic numbers). Lessons banked from
245// MEASURED failures: per-sample SGD plateaued 141/149; per-sample Adam collapsed to the
246// 88-sample majority (88/149); unweighted full-batch Adam left EXACTLY the two rarest classes
247// wrong (all 5 util + both mon = 142/149) -- on 88:2 imbalance the minority gradient only
248// survives inside a CLASS-BALANCED full-batch sum.
249func t4_cen_train(tape: *i64, nb: *i64, arena: *i64, ab: *i64, xs: *i64, ts: *i64, wts: *i64, cnt: i64, w: *i64, logfd: i64, out2: *i64, curve: *i64, curven: *i64) -> i64 {
  let w1n: i64 = t4_w1n()
  let w2n: i64 = T4_NCLS * T4_HID
  t4_init(w, w1n, 1, 16)
  var z: i64 = t4_b1o()
  while z < t4_w2o() { w[z] = 0; z = z + 1 }
  t4_init((w as i64 + t4_w2o()*8) as *i64, w2n, 2, 16)
  z = t4_b2o()
  while z < t4_tot() { w[z] = 0; z = z + 1 }
  let lr: i64 = tg_q(1, 20)
  let b1c: i64 = tg_q(9, 10)
  let b2c: i64 = tg_q(999, 1000)
  let eps: i64 = tg_q(1, 100000)
  let mw1: *i64 = sys_mmap(4096) as *i64
  let vw1: *i64 = sys_mmap(4096) as *i64
  let mb1: *i64 = sys_mmap(1024) as *i64
  let vb1: *i64 = sys_mmap(1024) as *i64
  let mw2: *i64 = sys_mmap(4096) as *i64
  let vw2: *i64 = sys_mmap(4096) as *i64
  let mb2: *i64 = sys_mmap(1024) as *i64
  let vb2: *i64 = sys_mmap(1024) as *i64
  let gaw1: *i64 = sys_mmap(4096) as *i64
  let gab1: *i64 = sys_mmap(1024) as *i64
  let gaw2: *i64 = sys_mmap(4096) as *i64
  let gab2: *i64 = sys_mmap(1024) as *i64
  let invn: i64 = nx_f32_div(nx_i32_to_f32(1), nx_i32_to_f32(cnt))
  curven[0] = 0
  curven[1] = 0 - 1
  var ep: i64 = 0
  while ep < T4_CEN_EPOCHS {
      var epsum: i64 = 0
      var z2: i64 = 0
      while z2 < w1n { gaw1[z2] = 0; z2 = z2 + 1 }
      z2 = 0
      while z2 < T4_HID { gab1[z2] = 0; z2 = z2 + 1 }
      z2 = 0
      while z2 < w2n { gaw2[z2] = 0; z2 = z2 + 1 }
      z2 = 0
      while z2 < T4_NCLS { gab2[z2] = 0; z2 = z2 + 1 }
      var s: i64 = 0
      while s < cnt {
          nb[0] = 0
          ab[0] = 0
          let lw1: i64 = tg_leaf(tape, nb, arena, ab, w, T4_HID, T4_INB)
          let lb1: i64 = tg_leaf(tape, nb, arena, ab, (w as i64 + t4_b1o()*8) as *i64, T4_HID, 1)
          let lw2: i64 = tg_leaf(tape, nb, arena, ab, (w as i64 + t4_w2o()*8) as *i64, T4_NCLS, T4_HID)
          let lb2: i64 = tg_leaf(tape, nb, arena, ab, (w as i64 + t4_b2o()*8) as *i64, T4_NCLS, 1)
          let lx: i64 = tg_leaf(tape, nb, arena, ab, (xs as i64 + s*T4_INB*8) as *i64, T4_INB, 1)
          let lt: i64 = tg_leaf(tape, nb, arena, ab, (ts as i64 + s*T4_NCLS*8) as *i64, T4_NCLS, 1)
          let hh: i64 = tg_reluvec(tape, nb, arena, ab, tg_addvec(tape, nb, arena, ab, tg_matvec(tape, nb, arena, ab, lw1, lx), lb1))
          let oo: i64 = tg_addvec(tape, nb, arena, ab, tg_matvec(tape, nb, arena, ab, lw2, hh), lb2)
          let lwt: i64 = tg_leaf(tape, nb, arena, ab, (wts as i64 + s*8) as *i64, 1, 1)
          let loss: i64 = tg_smul(tape, nb, arena, ab, tg_mse(tape, nb, arena, ab, oo, lt), lwt)
          tg_backward(tape, nb[0], loss)
          let lv: *i64 = tg_valp(tape, loss)
          epsum = nx_f32_add(epsum, lv[0])
          let pg1: *i64 = tg_gradp(tape, lw1)
          var q: i64 = 0
          while q < w1n { gaw1[q] = nx_f32_add(gaw1[q], pg1[q]); q = q + 1 }
          let pb1: *i64 = tg_gradp(tape, lb1)
          q = 0
          while q < T4_HID { gab1[q] = nx_f32_add(gab1[q], pb1[q]); q = q + 1 }
          let pg2: *i64 = tg_gradp(tape, lw2)
          q = 0
          while q < w2n { gaw2[q] = nx_f32_add(gaw2[q], pg2[q]); q = q + 1 }
          let pb2: *i64 = tg_gradp(tape, lb2)
          q = 0
          while q < T4_NCLS { gab2[q] = nx_f32_add(gab2[q], pb2[q]); q = q + 1 }
          s = s + 1
      }
      var lrcur: i64 = lr
      if ep >= (T4_CEN_EPOCHS * 4) / 5 { lrcur = nx_f32_div(lr, nx_i32_to_f32(8)) }
      ad_step(w, gaw1, mw1, vw1, w1n, lrcur, b1c, b2c, eps, 0, ep + 1)
      ad_step((w as i64 + t4_b1o()*8) as *i64, gab1, mb1, vb1, T4_HID, lrcur, b1c, b2c, eps, 0, ep + 1)
      ad_step((w as i64 + t4_w2o()*8) as *i64, gaw2, mw2, vw2, w2n, lrcur, b1c, b2c, eps, 0, ep + 1)
      ad_step((w as i64 + t4_b2o()*8) as *i64, gab2, mb2, vb2, T4_NCLS, lrcur, b1c, b2c, eps, 0, ep + 1)
      let avg: i64 = nx_f32_mul(epsum, invn)
      if ep == 0 { out2[0] = avg }
      out2[1] = avg
      let micro: i64 = tg_milli(nx_f32_mul(avg, nx_i32_to_f32(1000)))
      if ep % T4_LOG_EVERY == 0 {
          if curven[0] < 120 {
              curve[curven[0]*2+0] = ep
              curve[curven[0]*2+1] = micro
              curven[0] = curven[0] + 1
          }
          if logfd >= 0 {
              t4_bp(logfd, "MODELWRIGHT T4 LOSSCURVE ep=" as *u8); t4_bn(logfd, ep)
              t4_bp(logfd, " loss_micro=" as *u8); t4_bn(logfd, micro); t4_bp(logfd, "\n" as *u8)
          }
      }
      // EARLY STOP at convergence (deterministic: stop epoch is a pure function of the losses).
      // Measured failure this guards: at constant lr Adam CONVERGED at ~ep600 (loss ~0) then
      // BLEW UP at ep800 (grads->0 => v->0 => update ~ mh/eps spikes) and landed in a worse basin.
      if nx_f32_lt(avg, tg_q(1, 250000)) == 1 {
          if curven[0] < 120 {
              curve[curven[0]*2+0] = ep
              curve[curven[0]*2+1] = micro
              curven[0] = curven[0] + 1
          }
          curven[1] = ep
          if logfd >= 0 { t4_bp(logfd, "MODELWRIGHT T4 CONVERGED ep=" as *u8); t4_bn(logfd, ep); t4_bp(logfd, "\n" as *u8) }
          ep = T4_CEN_EPOCHS
      } else { ep = ep + 1 }
  }
  return 0
355}
356
357// XOR model plain forward (layout: w1[0..15] b1[16..23] w2[24..31] b2[32])
358func t4_xor_fwd(w: *i64, x0: i64, x1: i64) -> i64 {
  let h: *i64 = sys_mmap(128) as *i64
  var i: i64 = 0
  while i < 8 {
      var s: i64 = w[16+i]
      s = nx_f32_add(s, nx_f32_mul(w[i*2+0], x0))
      s = nx_f32_add(s, nx_f32_mul(w[i*2+1], x1))
      if nx_f32_lt(s, 0) == 1 { s = 0 }
      h[i] = s
      i = i + 1
  }
  var o: i64 = w[32]
  i = 0
  while i < 8 { o = nx_f32_add(o, nx_f32_mul(w[24+i], h[i])); i = i + 1 }
  return o
373}
374
375// train XOR 2-8-1 with AdamW full-batch; out2 = {first, final} loss
376func t4_xor_train(tape: *i64, nb: *i64, arena: *i64, ab: *i64, w: *i64, out2: *i64) -> i64 {
  t4_init(w, 16, 3, 8)
  var z: i64 = 16
  while z < 24 { w[z] = 0; z = z + 1 }
  t4_init((w as i64 + 24*8) as *i64, 8, 4, 8)
  w[32] = 0
  let xs: *i64 = sys_mmap(128) as *i64
  let ys: *i64 = sys_mmap(64) as *i64
  xs[0] = 0; xs[1] = 0; ys[0] = 0
  xs[2] = 0; xs[3] = nx_i32_to_f32(1); ys[1] = nx_i32_to_f32(1)
  xs[4] = nx_i32_to_f32(1); xs[5] = 0; ys[2] = nx_i32_to_f32(1)
  xs[6] = nx_i32_to_f32(1); xs[7] = nx_i32_to_f32(1); ys[3] = 0
  let inv4: *i64 = sys_mmap(64) as *i64
  inv4[0] = tg_q(1, 4)
  let lr: i64 = tg_q(1, 20)
  let b1c: i64 = tg_q(9, 10)
  let b2c: i64 = tg_q(999, 1000)
  let eps: i64 = tg_q(1, 100000)
  let mw1: *i64 = sys_mmap(128) as *i64
  let vw1: *i64 = sys_mmap(128) as *i64
  let mb1: *i64 = sys_mmap(64) as *i64
  let vb1: *i64 = sys_mmap(64) as *i64
  let mw2: *i64 = sys_mmap(64) as *i64
  let vw2: *i64 = sys_mmap(64) as *i64
  let mb2: *i64 = sys_mmap(32) as *i64
  let vb2: *i64 = sys_mmap(32) as *i64
  var ep: i64 = 0
  while ep < T4_XOR_EPOCHS {
      nb[0] = 0
      ab[0] = 0
      let lw1: i64 = tg_leaf(tape, nb, arena, ab, w, 8, 2)
      let lb1: i64 = tg_leaf(tape, nb, arena, ab, (w as i64 + 16*8) as *i64, 8, 1)
      let lw2: i64 = tg_leaf(tape, nb, arena, ab, (w as i64 + 24*8) as *i64, 1, 8)
      let lb2: i64 = tg_leaf(tape, nb, arena, ab, (w as i64 + 32*8) as *i64, 1, 1)
      var accn: i64 = 0 - 1
      var k: i64 = 0
      while k < 4 {
          let lx: i64 = tg_leaf(tape, nb, arena, ab, (xs as i64 + k*16) as *i64, 2, 1)
          let lt: i64 = tg_leaf(tape, nb, arena, ab, (ys as i64 + k*8) as *i64, 1, 1)
          let hh: i64 = tg_reluvec(tape, nb, arena, ab, tg_addvec(tape, nb, arena, ab, tg_matvec(tape, nb, arena, ab, lw1, lx), lb1))
          let oo: i64 = tg_addvec(tape, nb, arena, ab, tg_matvec(tape, nb, arena, ab, lw2, hh), lb2)
          let m: i64 = tg_mse(tape, nb, arena, ab, oo, lt)
          if accn < 0 { accn = m } else { accn = tg_addvec(tape, nb, arena, ab, accn, m) }
          k = k + 1
      }
      let li: i64 = tg_leaf(tape, nb, arena, ab, inv4, 1, 1)
      let loss: i64 = tg_smul(tape, nb, arena, ab, accn, li)
      tg_backward(tape, nb[0], loss)
      let lv: *i64 = tg_valp(tape, loss)
      if ep == 0 { out2[0] = lv[0] }
      out2[1] = lv[0]
      ad_step(w, tg_gradp(tape, lw1), mw1, vw1, 16, lr, b1c, b2c, eps, 0, ep + 1)
      ad_step((w as i64 + 16*8) as *i64, tg_gradp(tape, lb1), mb1, vb1, 8, lr, b1c, b2c, eps, 0, ep + 1)
      ad_step((w as i64 + 24*8) as *i64, tg_gradp(tape, lw2), mw2, vw2, 8, lr, b1c, b2c, eps, 0, ep + 1)
      ad_step((w as i64 + 32*8) as *i64, tg_gradp(tape, lb2), mb2, vb2, 1, lr, b1c, b2c, eps, 0, ep + 1)
      ep = ep + 1
  }
  return 0
434}
435
436func main(argc: i64, argv: *i64) -> i64 {
  _tg_puts("=== T4 FIRST REAL MODEL (composes the GATED T6/T5 core; XOR nonconvex + REAL census corpus; bit-exact) ===\n" as *u8)
  // optional argv[1] = census path override -- the Referee's tamper hook (prove the gate goes RED)
  var cpath: *u8 = "knowledge/status/elder_census.log" as *u8
  if argc >= 2 { cpath = argv[1] as *u8 }
  let lfd: i64 = sys_openat_append("knowledge/status/modelwright.log" as *u8, 0x1a4)
  if lfd < 0 { _tg_puts(" modelwright log open FAILED\n" as *u8); sys_exit(1); return 1 }
  t4_fp(lfd, "MODELWRIGHT T4 RUN epoch_unix=" as *u8); t4_fn(lfd, sys_now_realtime_sec()); t4_fp(lfd, "\n" as *u8)
444
  let tape: *i64 = sys_mmap(32768) as *i64
  let nb: *i64 = sys_mmap(16) as *i64
  let arena: *i64 = sys_mmap(131072) as *i64
  let ab: *i64 = sys_mmap(16) as *i64
449
  // ---- GATE O: parse the REAL census; the file's own CENSUS-SUM is the oracle ----
  let names: *u8 = sys_mmap(8192)
  let labels: *i64 = sys_mmap(2048) as *i64
  let sums: *i64 = sys_mmap(128) as *i64
  var si: i64 = 0
  while si < 9 { sums[si] = 0 - 1; si = si + 1 }
  let cnt: i64 = t4_parse(cpath, names, labels, sums)
  var po: i64 = 1
  if cnt <= 0 { po = 0 }
  if sums[8] != cnt { po = 0 }
  let hist: *i64 = sys_mmap(128) as *i64
  var s2: i64 = 0
  while s2 < cnt { hist[labels[s2]] = hist[labels[s2]] + 1; s2 = s2 + 1 }
  var c2: i64 = 0
  while c2 < T4_NCLS {
      if hist[c2] != sums[c2] { po = 0 }
      c2 = c2 + 1
  }
  t4_bp(lfd, "MODELWRIGHT T4 DATA services=" as *u8); t4_bn(lfd, cnt)
  t4_bp(lfd, " svc=" as *u8); t4_bn(lfd, hist[0])
  t4_bp(lfd, " gen=" as *u8); t4_bn(lfd, hist[1])
  t4_bp(lfd, " data=" as *u8); t4_bn(lfd, hist[2])
  t4_bp(lfd, " orch=" as *u8); t4_bn(lfd, hist[3])
  t4_bp(lfd, " worker=" as *u8); t4_bn(lfd, hist[4])
  t4_bp(lfd, " mon=" as *u8); t4_bn(lfd, hist[5])
  t4_bp(lfd, " util=" as *u8); t4_bn(lfd, hist[6])
  t4_bp(lfd, " other=" as *u8); t4_bn(lfd, hist[7])
  if po == 1 { t4_bp(lfd, " sum_oracle=MATCH\n" as *u8) } else { t4_bp(lfd, " sum_oracle=MISMATCH\n" as *u8) }
  if po == 1 { _tg_puts(" GATE O census parse == CENSUS-SUM ground truth: PASS\n" as *u8) } else { _tg_puts(" GATE O census-parse oracle: FAIL\n" as *u8) }
479
  // ---- GATE G: XOR (the nonconvex proof; deterministic init kills the zero-init trap) ----
  let wx1: *i64 = sys_mmap(256) as *i64
  let ox1: *i64 = sys_mmap(64) as *i64
  t4_xor_train(tape, nb, arena, ab, wx1, ox1)
  var pg: i64 = 1
  if nx_f32_lt(ox1[1], tg_q(1, 100)) == 0 { pg = 0 }
  if nx_f32_lt(ox1[1], ox1[0]) == 0 { pg = 0 }
  let one: i64 = nx_i32_to_f32(1)
  var okp: i64 = 0
  var k: i64 = 0
  while k < 4 {
      var xa: i64 = 0
      var xb: i64 = 0
      var tv: i64 = 0
      if k == 1 { xb = one; tv = one }
      if k == 2 { xa = one; tv = one }
      if k == 3 { xa = one; xb = one }
      let pr: i64 = t4_xor_fwd(wx1, xa, xb)
      if nx_f32_lt(nx_f32_abs(nx_f32_sub(pr, tv)), tg_q(1, 4)) == 1 { okp = okp + 1 }
      k = k + 1
  }
  if okp != 4 { pg = 0 }
  t4_bp(lfd, "MODELWRIGHT T4 XOR loss_milli=" as *u8); t4_bn(lfd, tg_milli(ox1[1]))
  t4_bp(lfd, " preds_ok=" as *u8); t4_bn(lfd, okp); t4_bp(lfd, "/4\n" as *u8)
  if pg == 1 { _tg_puts(" GATE G XOR learned (2-8-1 relu MLP + AdamW, deterministic init): PASS\n" as *u8) } else { _tg_puts(" GATE G XOR: FAIL\n" as *u8) }
505
  // ---- GATE H: census model trains to 100% on the real corpus ----
  let xs: *i64 = sys_mmap(16384) as *i64
  let ts: *i64 = sys_mmap(16384) as *i64
  t4_featurize(names, labels, cnt, xs, ts)
  let wts: *i64 = sys_mmap(2048) as *i64
  s2 = 0
  while s2 < cnt { wts[s2] = nx_f32_div(tg_q(1, T4_NCLS), nx_i32_to_f32(hist[labels[s2]])); s2 = s2 + 1 }
  let wc1: *i64 = sys_mmap(4096) as *i64
  let oc1: *i64 = sys_mmap(64) as *i64
  let curve: *i64 = sys_mmap(4096) as *i64
  let curven: *i64 = sys_mmap(32) as *i64
  t4_cen_train(tape, nb, arena, ab, xs, ts, wts, cnt, wc1, lfd, oc1, curve, curven)
  let out8: *i64 = sys_mmap(128) as *i64
  let pcount: *i64 = sys_mmap(128) as *i64
  var acc: i64 = 0
  s2 = 0
  while s2 < cnt {
      let pred: i64 = t4_cen_fwd(wc1, (xs as i64 + s2*T4_INB*8) as *i64, out8)
      pcount[pred] = pcount[pred] + 1
      if pred == labels[s2] { acc = acc + 1 } else {
          _tg_puts("  MISS name=" as *u8); _tg_puts((names as i64 + s2*24) as *u8)
          _tg_puts(" label=" as *u8); _tg_num(labels[s2])
          _tg_puts(" pred=" as *u8); _tg_num(pred); _tg_puts("\n" as *u8)
      }
      s2 = s2 + 1
  }
  var ph: i64 = 1
  if acc != cnt { ph = 0 }
  c2 = 0
  while c2 < T4_NCLS {
      if pcount[c2] != hist[c2] { ph = 0 }
      c2 = c2 + 1
  }
  if nx_f32_lt(oc1[1], oc1[0]) == 0 { ph = 0 }
  t4_bp(lfd, "MODELWRIGHT T4 CENSUS acc=" as *u8); t4_bn(lfd, acc)
  t4_bp(lfd, "/" as *u8); t4_bn(lfd, cnt)
  t4_bp(lfd, " first_loss_milli=" as *u8); t4_bn(lfd, tg_milli(oc1[0]))
  t4_bp(lfd, " final_loss_milli=" as *u8); t4_bn(lfd, tg_milli(oc1[1])); t4_bp(lfd, "\n" as *u8)
  if ph == 1 { _tg_puts(" GATE H census model 100% on the REAL corpus (per-class counts == ground truth): PASS\n" as *u8) } else { _tg_puts(" GATE H census model: FAIL\n" as *u8) }
545
  // ---- GATE I: bit-exact two-run training, both lanes (the standing EXCEED axis) ----
  let wx2: *i64 = sys_mmap(256) as *i64
  let ox2: *i64 = sys_mmap(64) as *i64
  t4_xor_train(tape, nb, arena, ab, wx2, ox2)
  let wc2: *i64 = sys_mmap(4096) as *i64
  let oc2: *i64 = sys_mmap(64) as *i64
  let curve2: *i64 = sys_mmap(4096) as *i64
  let curven2: *i64 = sys_mmap(32) as *i64
  t4_cen_train(tape, nb, arena, ab, xs, ts, wts, cnt, wc2, 0 - 1, oc2, curve2, curven2)
  var pi: i64 = 1
  k = 0
  while k < 33 { if wx1[k] != wx2[k] { pi = 0 } k = k + 1 }
  k = 0
  while k < t4_tot() { if wc1[k] != wc2[k] { pi = 0 } k = k + 1 }
  t4_bp(lfd, "MODELWRIGHT T4 BITEXACT xor_cells=33 census_cells=" as *u8); t4_bn(lfd, t4_tot())
  t4_bp(lfd, " identical=" as *u8); t4_bn(lfd, pi); t4_bp(lfd, "\n" as *u8)
  if pi == 1 { _tg_puts(" GATE I bit-exact two-run training (xor + census weight cells identical): PASS\n" as *u8) } else { _tg_puts(" GATE I bit-exact: FAIL\n" as *u8) }
563
  // ---- machine-readable training report for nx_train_triage (override runs -> /tmp,
  // never the durable path: the T4b report-clobber lesson) ----
  var rpath: *u8 = "knowledge/status/train_report_t4.log" as *u8
  if argc >= 2 { rpath = "/tmp/_t4_report_override.log" as *u8 }
  let rfd: i64 = sys_openat_wr(rpath, 0x1a4)
  if rfd >= 0 {
      c2 = 0
      while c2 < T4_NCLS {
          t4_fp(rfd, "TRIAGE-CLASS id=" as *u8); t4_fn(rfd, c2)
          t4_fp(rfd, " count=" as *u8); t4_fn(rfd, hist[c2]); t4_fp(rfd, "\n" as *u8)
          c2 = c2 + 1
      }
      c2 = 0
      while c2 < T4_NCLS {
          t4_fp(rfd, "TRIAGE-PRED id=" as *u8); t4_fn(rfd, c2)
          t4_fp(rfd, " count=" as *u8); t4_fn(rfd, pcount[c2]); t4_fp(rfd, "\n" as *u8)
          c2 = c2 + 1
      }
      t4_fp(rfd, "TRIAGE-ACC right=" as *u8); t4_fn(rfd, acc)
      t4_fp(rfd, " total=" as *u8); t4_fn(rfd, cnt); t4_fp(rfd, "\n" as *u8)
      var ci: i64 = 0
      while ci < curven[0] {
          t4_fp(rfd, "TRIAGE-LOSS ep=" as *u8); t4_fn(rfd, curve[ci*2+0])
          t4_fp(rfd, " micro=" as *u8); t4_fn(rfd, curve[ci*2+1]); t4_fp(rfd, "\n" as *u8)
          ci = ci + 1
      }
      sys_close(rfd)
      _tg_puts(" training report written: " as *u8); _tg_puts(rpath); _tg_puts("\n" as *u8)
  }
593
  var gates: i64 = 0
  if po == 1 { gates = gates + 1 }
  if pg == 1 { gates = gates + 1 }
  if ph == 1 { gates = gates + 1 }
  if pi == 1 { gates = gates + 1 }
  t4_bp(lfd, "MODELWRIGHT T4 VERDICT gates=" as *u8); t4_bn(lfd, gates)
  t4_bp(lfd, "/4" as *u8)
  if gates == 4 { t4_bp(lfd, " pass=1\n" as *u8) } else { t4_bp(lfd, " pass=0\n" as *u8) }
  sys_close(lfd)
  if gates == 4 {
      _tg_puts(" T4 FIRST-MODEL GATE: PASS (first real models trained on the team substrate, real team data, bit-exact)\n" as *u8)
      sys_exit(0)
      return 0
  }
  _tg_puts(" T4 FIRST-MODEL GATE: FAIL\n" as *u8)
  sys_exit(1)
  return 1
611}
_t4_first_model_authored.nx source

`_t4_first_model_authored.nx` source
