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

↩ module page · 269 lines · 10869 B
1// nx_jina_embed_gate.nx -- E-ARC e2: JINA-WEIGHT ORACLE gate (2026-07-15). Runs the SAME sovereign
2// integer embed path (nsv_embed, last-token pooled final-norm, i8 mode) on the DOWNLOADED
3// jina-code-embeddings-0.5b Q8_0 weights (sha256-verified vs origin ETag; arch-identical Qwen2.5-Coder
4// backbone) and grades our pipeline against the model card's bf16 2x2 cosine oracle 817/124/120/553 pm.
5// cc-by-nc-4.0 weights -> BENCHMARK ORACLE ONLY (like gcc), never the production embedder.
6// GATES:
7//   A  ORDER      cos(q1,p1)>cos(q1,p2) AND cos(q2,p2)>cos(q2,p1)
8//   A2 SEPARATION tuned margins (c11-c12) and (c22-c21) must EXCEED 300 pm -- the discriminating test
9//                 vs BASE-coder arm (nx_code_embed_gate measured margins 72/49 pm): only truly-loaded
10//                 tuned weights can show the oracle's ~693/433 pm class separation.
11//   B  DETERM     re-embed q1 after all other texts -> BITWISE identical (KV/state-leak liar killer)
12//   C  SELF       cos(q1,q1') >= 999 pm
13//   D  RETRIEVE   Nishi 3x3 NL->code diagonal 3/3 (vs base arm for margin comparison)
14//   F  DISTRACTOR unrelated prose passage must lose to the true match on BOTH queries (NEG control)
15// license_tier: ORIGINAL   No hw writes (Rule 26).   expect_exit: 0
16import "nx_nofloat_serve_core.nx"
17
18const CE_NE: i64 = 896
19const CE_SLOTS: i64 = 12
20
21func ce_ws(s: *u8) -> i64 {
  var n: i64 = 0
  while s[n] != (0 as u8) { n = n + 1 }
  sys_write(1, s, n)
  return 0
26}
27
28func ce_wdec(v: i64) -> i64 {
  let b: *u8 = sys_mmap(28)
  let t: *u8 = sys_mmap(28)
  var m: i64 = v
  if m < 0 { ce_ws("-" as *u8); m = 0 - m }
  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
40}
41
42func ce_kv(label: *u8, v: i64) -> i64 {
  ce_ws(label)
  ce_ws("=" as *u8)
  ce_wdec(v)
  ce_ws(" " as *u8)
  return 0
48}
49
50func ce_isqrt(v: i64) -> i64 {
  if v < 2 { return v }
  var x: i64 = v
  var y: i64 = (x + 1) / 2
  while y < x { x = y; y = (x + v / x) / 2 }
  return x
56}
57
58// cosine similarity in per-mille, overflow-safe: pre-scale both vectors by the SAME power of two so
59// max|elem| <= 2^20 -> squares*ne <= 2^50, dot*1000 <= 2^60, isqrt product <= 2^50 (all inside i64).
60func ce_cos_pm(a: *i64, b: *i64) -> i64 {
  var mx: i64 = 1
  var i: i64 = 0
  while i < CE_NE {
      var va: i64 = a[i]
      if va < 0 { va = 0 - va }
      var vb: i64 = b[i]
      if vb < 0 { vb = 0 - vb }
      if va > mx { mx = va }
      if vb > mx { mx = vb }
      i = i + 1
  }
  var dv: i64 = 1
  while mx > 1048575 { mx = mx / 2; dv = dv * 2 }
  var dab: i64 = 0
  var daa: i64 = 0
  var dbb: i64 = 0
  i = 0
  while i < CE_NE {
      let ea: i64 = a[i] / dv
      let eb: i64 = b[i] / dv
      dab = dab + ea * eb
      daa = daa + ea * ea
      dbb = dbb + eb * eb
      i = i + 1
  }
  let sa: i64 = ce_isqrt(daa)
  let sb: i64 = ce_isqrt(dbb)
  if sa == 0 { return 0 }
  if sb == 0 { return 0 }
  return (dab * 1000) / (sa * sb)
91}
92
93func ce_bytes_eq(a: *i64, b: *i64) -> i64 {
  var i: i64 = 0
  while i < CE_NE { if a[i] != b[i] { return 0 } i = i + 1 }
  return 1
97}
98
99func ce_maxabs(a: *i64) -> i64 {
  var mx: i64 = 0
  var i: i64 = 0
  while i < CE_NE {
      var v: i64 = a[i]
      if v < 0 { v = 0 - v }
      if v > mx { mx = v }
      i = i + 1
  }
  return mx
109}
110
111// embed prefix+content into vec slot; prints slot/ntok/ms; returns ntok (negative = error)
112func ce_embed(vecs: *i64, slot: i64, pre: *u8, content: *u8) -> i64 {
  let txt: *u8 = sys_mmap(2048)
  var l: i64 = nsv_cat(txt, 0, pre)
  l = nsv_cat(txt, l, content)
  let vp_i: i64 = (vecs as i64) + slot * CE_NE * 8
  let vp: *i64 = vp_i as *i64
  let t0: i64 = sys_now_ms()
  let n: i64 = nsv_embed(txt, l, 1, vp)
  let t1: i64 = sys_now_ms()
  ce_ws("[embed] " as *u8)
  ce_kv("slot" as *u8, slot)
  ce_kv("ntok" as *u8, n)
  ce_kv("ms" as *u8, t1 - t0)
  ce_ws("\n" as *u8)
  return n
127}
128
129func ce_vp(vecs: *i64, slot: i64) -> *i64 {
  let p: i64 = (vecs as i64) + slot * CE_NE * 8
  return p as *i64
132}
133
134func main() -> i64 {
  ce_ws("[jina-oracle-gate] sovereign integer embed path on jina-code-embeddings-0.5b Q8_0 (benchmark oracle, cc-by-nc-4.0)\n" as *u8)
  let ir: i64 = nsv_init("/home/elderwesto/nx_stage/nx_jina_embed_model.gguf\x00" as *u8)
  if ir != 0 {
      ce_kv("[jina-oracle-gate] INIT-FAIL rc" as *u8, ir)
      ce_ws("\n" as *u8)
      return 1
  }
  let vecs: *i64 = sys_mmap(CE_SLOTS * CE_NE * 8) as *i64
  // jina EXACT task instruction prefixes (nl2code)
  let qp: *u8 = "Find the most relevant code snippet given the following query:\n" as *u8
  let pp: *u8 = "Candidate code snippet:\n" as *u8
  // jina model-card 2x2 demo (bf16 jina-tuned oracle: q1p1=817 q1p2=124 q2p1=120 q2p2=553 pm)
  var rc: i64 = 0
  rc = ce_embed(vecs, 0, qp, "print hello world in python" as *u8)
  if rc < 1 { return 1 }
  rc = ce_embed(vecs, 1, qp, "initialize array of 5 zeros in c++" as *u8)
  if rc < 1 { return 1 }
  rc = ce_embed(vecs, 2, pp, "print('Hello World!')" as *u8)
  if rc < 1 { return 1 }
  rc = ce_embed(vecs, 3, pp, "int arr[5] = {0, 0, 0, 0, 0};" as *u8)
  if rc < 1 { return 1 }
  // Nishi-corpus 3x3 micro-retrieval (REAL API shapes from runtime/) -- base-arm comparison rows
  rc = ce_embed(vecs, 4, qp, "read a u32 metadata value from a gguf header by key" as *u8)
  if rc < 1 { return 1 }
  rc = ce_embed(vecs, 5, qp, "connect to a unix domain socket at a filesystem path" as *u8)
  if rc < 1 { return 1 }
  rc = ce_embed(vecs, 6, qp, "rms normalize a hidden row with gamma weights in fixed point" as *u8)
  if rc < 1 { return 1 }
  rc = ce_embed(vecs, 7, pp, "nx_gguf_meta_find(buf, flen, hdr, key, klen, voff, vty)\nlet v: i64 = nx_gguf_meta_read_u32(buf, voff[0])" as *u8)
  if rc < 1 { return 1 }
  rc = ce_embed(vecs, 8, pp, "let fd: i64 = sys_socket(1, 1, 0)\nsa[0] = 1 as u8\nsys_connect(fd, sa as *u8, 110)" as *u8)
  if rc < 1 { return 1 }
  rc = ce_embed(vecs, 9, pp, "rmsnorm_gamma_row_q24(h1, gout, 0, ne, normed, 0)" as *u8)
  if rc < 1 { return 1 }
  // B: re-embed q1 AFTER all corpus texts -> must be BITWISE identical to slot 0
  rc = ce_embed(vecs, 10, qp, "print hello world in python" as *u8)
  if rc < 1 { return 1 }
  // F: unrelated prose distractor passage (NEG control)
  rc = ce_embed(vecs, 11, pp, "The weather is sunny today and the birds are singing in the park." as *u8)
  if rc < 1 { return 1 }
  ce_kv("[scale] maxabs_q24_slot0" as *u8, ce_maxabs(ce_vp(vecs, 0)))
  // ⚠HOISTED: `ce_vp(vecs, 0)[0]` INDEXES A CALL RESULT, which nx_cc miscompiles SILENTLY -- it does not
  // crash and printed output still looks right, but the value read is wrong (debt 1785532031, gotcha
  // banked 2026-07-31; prior in-code sightings: nx_pagerank_build_gate.nx:38 'inline cast-index
  // miscompiles' and nx_rw_emptystr.nx 'aliases the next literal'). This site is INSIDE A GATE, so a bad
  // read corrupts this gate's own evidence. Assign to a temp, then index the temp.
  let v0p: *i64 = ce_vp(vecs, 0)
  ce_kv("v0" as *u8, v0p[0])
  ce_ws("(weight-identity evidence: must differ from base-arm values)\n" as *u8)
  // ---- jina 2x2 vs bf16 oracle ----
  let c11: i64 = ce_cos_pm(ce_vp(vecs, 0), ce_vp(vecs, 2))
  let c12: i64 = ce_cos_pm(ce_vp(vecs, 0), ce_vp(vecs, 3))
  let c21: i64 = ce_cos_pm(ce_vp(vecs, 1), ce_vp(vecs, 2))
  let c22: i64 = ce_cos_pm(ce_vp(vecs, 1), ce_vp(vecs, 3))
  ce_ws("[jina-2x2 pm] " as *u8)
  ce_kv("q1p1" as *u8, c11)
  ce_kv("q1p2" as *u8, c12)
  ce_kv("q2p1" as *u8, c21)
  ce_kv("q2p2" as *u8, c22)
  ce_ws("(bf16 oracle: 817 124 120 553)\n" as *u8)
  ce_ws("[oracle-delta pm] " as *u8)
  ce_kv("d11" as *u8, c11 - 817)
  ce_kv("d12" as *u8, c12 - 124)
  ce_kv("d21" as *u8, c21 - 120)
  ce_kv("d22" as *u8, c22 - 553)
  ce_ws("\n" as *u8)
  var gate_a: i64 = 0
  if c11 > c12 { if c22 > c21 { gate_a = 1 } }
  // A2: tuned separation (base arm measured margins 72/49 pm; oracle margins 693/433 pm)
  let m1: i64 = c11 - c12
  let m2: i64 = c22 - c21
  var gate_a2: i64 = 0
  if m1 > 300 { if m2 > 300 { gate_a2 = 1 } }
  ce_ws("[separation pm] " as *u8)
  ce_kv("margin1" as *u8, m1)
  ce_kv("margin2" as *u8, m2)
  ce_ws("(base arm: 72 49; oracle: 693 433; gate >300)\n" as *u8)
  // ---- determinism / state-leak ----
  let gate_b: i64 = ce_bytes_eq(ce_vp(vecs, 0), ce_vp(vecs, 10))
  let selfpm: i64 = ce_cos_pm(ce_vp(vecs, 0), ce_vp(vecs, 10))
  var gate_c: i64 = 0
  if selfpm >= 999 { gate_c = 1 }
  ce_ws("[determinism] " as *u8)
  ce_kv("bitwise_eq" as *u8, gate_b)
  ce_kv("self_pm" as *u8, selfpm)
  ce_ws("\n" as *u8)
  // ---- nishi 3x3 retrieval ----
  var hits: i64 = 0
  var r: i64 = 0
  while r < 3 {
      let s0: i64 = ce_cos_pm(ce_vp(vecs, 4 + r), ce_vp(vecs, 7))
      let s1: i64 = ce_cos_pm(ce_vp(vecs, 4 + r), ce_vp(vecs, 8))
      let s2: i64 = ce_cos_pm(ce_vp(vecs, 4 + r), ce_vp(vecs, 9))
      var am: i64 = 0
      var best: i64 = s0
      if s1 > best { am = 1; best = s1 }
      if s2 > best { am = 2; best = s2 }
      ce_ws("[nishi-3x3] " as *u8)
      ce_kv("row" as *u8, r)
      ce_kv("s0" as *u8, s0)
      ce_kv("s1" as *u8, s1)
      ce_kv("s2" as *u8, s2)
      ce_kv("argmax" as *u8, am)
      if am == r { hits = hits + 1; ce_ws("HIT\n" as *u8) } else { ce_ws("MISS\n" as *u8) }
      r = r + 1
  }
  ce_kv("[retrieval] hits" as *u8, hits)
  ce_ws("/3\n" as *u8)
  // ---- F: distractor NEG control ----
  let cd1: i64 = ce_cos_pm(ce_vp(vecs, 0), ce_vp(vecs, 11))
  let cd2: i64 = ce_cos_pm(ce_vp(vecs, 1), ce_vp(vecs, 11))
  var gate_f: i64 = 0
  if cd1 < c11 { if cd2 < c22 { gate_f = 1 } }
  ce_ws("[distractor pm] " as *u8)
  ce_kv("q1_vs_weather" as *u8, cd1)
  ce_kv("q2_vs_weather" as *u8, cd2)
  ce_kv("gate_f" as *u8, gate_f)
  ce_ws("\n" as *u8)
  // ---- verdict ----
  var green: i64 = 0
  if gate_a == 1 { if gate_a2 == 1 { if gate_b == 1 { if gate_c == 1 { if hits == 3 { if gate_f == 1 { green = 1 } } } } } }
  if green == 1 {
      ce_ws("VERDICT GREEN jina-weight-oracle (A order + A2 tuned-separation + B bitwise-determinism + C self + D 3/3 + F distractor; our integer embed path reproduces the tuned model's signature)\n" as *u8)
      return 0
  }
  ce_ws("VERDICT RED " as *u8)
  ce_kv("A" as *u8, gate_a)
  ce_kv("A2" as *u8, gate_a2)
  ce_kv("B" as *u8, gate_b)
  ce_kv("C" as *u8, gate_c)
  ce_kv("D" as *u8, hits)
  ce_kv("F" as *u8, gate_f)
  ce_ws("\n" as *u8)
  return 1
269}
nx_jina_embed_gate.nx source

`nx_jina_embed_gate.nx` source
