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

↩ module page · 200 lines · 11408 B
1// nx_food_recipe_gate.nx -- GATE: R-RECIPE. Mines the license-clean fetched corpora for ingredient
2// co-occurrence, validates the signal recovers the classic seeded pairings (research, not bro science),
3// and promotes the learned pairings into the durable store. Proves: T1 corpora mined, T2 LICENSE-GATED
4// mining (an inadmissible-tagged corpus is REFUSED -- negative control), T3 real signal found, T4 measured
5// validation (>=3 of the 15 seeded classic pairs independently confirmed by real recipe text; concrete
6// allium pairs printed), T5 promotion durable + readable, T6 facts-only (learned value is a bare count, no
7// prose). license_tier: ORIGINAL
8import "nx_food_recipe_mine.nx"
9import "nx_food_science.nx"
10import "nx_food_provenance.nx"
11import "nx_seg_store.nx"
12import "nx_syscalls.nx"
13
14const RG_DUR: *u8 = "knowledge/store/food-"
15
16func g_p(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 }
17func g_i(v: i64) -> i64 {
  let bb: *u8 = sys_mmap(28); var m: i64 = v
  if m < 0 { sys_write(1, "-" as *u8, 1); m = 0 - m }
  let t: *u8 = sys_mmap(28); 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 { bb[i] = t[k - 1 - i]; i = i + 1 } sys_write(1, bb, k); return 0
24}
25func g_name(world: *i64, idx: i64) -> i64 { let names: *i64 = world[4] as *i64; g_p(names[idx] as *u8); return 0 }
26
27func main() -> i64 {
  g_p("=== nx_food_recipe_gate (R-RECIPE: ground pairings in real recipes) ===\n" as *u8)
29
  // make sure the durable branch exists (idempotent)
  fd_seed(RG_DUR)
  fd_seed_provenance(RG_DUR)
  let world: *i64 = fd_world_open(RG_DUR)
  let n: i64 = world[0]
  if n == 0 { g_p("FATAL empty world\nverdict=RED\n" as *u8); return 1 }
36
  let termlc: *i64 = sys_mmap(8 * 64) as *i64
  let termlen: *i64 = sys_mmap(8 * 64) as *i64
  fm_build_terms(world, termlc, termlen)
  let cooc: *i64 = sys_mmap(8 * n * n) as *i64
  let pres: *i64 = sys_mmap(8 * 64) as *i64
42
  // corpus list (path, license). Entry 5 is a NEGATIVE CONTROL: a real file tagged copyrighted (ARR) ->
  // the license gate must REFUSE to mine it.
  let paths: *i64 = sys_mmap(8 * 8) as *i64
  let lics: *i64 = sys_mmap(8 * 8) as *i64
  paths[0] = "knowledge/fetched/food_r2_wikibooks_cookbook.raw" as *u8 as i64; lics[0] = "CCBYSA" as *u8 as i64
  paths[1] = "knowledge/fetched/food_r3_pd_cookbook.raw" as *u8 as i64;        lics[1] = "PD" as *u8 as i64
  paths[2] = "knowledge/fetched/food_c1_chinese.raw" as *u8 as i64;            lics[2] = "CCBYSA" as *u8 as i64
  paths[3] = "knowledge/fetched/food_t1_stir_frying.raw" as *u8 as i64;        lics[3] = "CCBYSA" as *u8 as i64
  paths[4] = "knowledge/fetched/food_r1_flavor_network.raw" as *u8 as i64;     lics[4] = "CCBY" as *u8 as i64
  paths[5] = "knowledge/fetched/food_c2_sichuan.raw" as *u8 as i64;            lics[5] = "ARR" as *u8 as i64
  let ncorp: i64 = 6
54
  var mined: i64 = 0
  var skipped: i64 = 0
  var totalbytes: i64 = 0
  var totalhits: i64 = 0
  let szp: *i64 = sys_mmap(16) as *i64
  var ci: i64 = 0
  while ci < ncorp {
      let path: *u8 = paths[ci] as *u8
      let lic: *u8 = lics[ci] as *u8
      if fd_source_admissible(RG_DUR, lic) == 0 {
          g_p("  REFUSED (license " as *u8); g_p(lic); g_p("): " as *u8); g_p(path); g_p("\n" as *u8)
          skipped = skipped + 1
      } else {
          let buf: *u8 = ss_readall(path, szp)
          let sz: i64 = szp[0]
          if sz > 0 {
              fm_lower(buf, sz)
              let hits: i64 = fm_mine(world, buf, sz, 800, termlc, termlen, cooc, pres)
              g_p("  mined (" as *u8); g_p(lic); g_p(", " as *u8); g_i(sz); g_p("B, hits=" as *u8); g_i(hits); g_p("): " as *u8); g_p(path); g_p("\n" as *u8)
              mined = mined + 1; totalbytes = totalbytes + sz; totalhits = totalhits + hits
          } else {
              g_p("  MISS (not on disk): " as *u8); g_p(path); g_p("\n" as *u8)
          }
      }
      ci = ci + 1
  }
81
  var pass: i64 = 0
  var tot: i64 = 0
84
  // T1 corpora mined
  tot = tot + 1
  if mined >= 4 { if totalbytes > 100000 { pass = pass + 1; g_p("PASS T1 mined " as *u8); g_i(mined); g_p(" license-clean corpora (" as *u8); g_i(totalbytes); g_p(" bytes)\n" as *u8) } else { g_p("FAIL T1 too few bytes\n" as *u8) } } else { g_p("FAIL T1 too few corpora mined=" as *u8); g_i(mined); g_p("\n" as *u8) }
88
  // T2 license-gated mining (negative control refused)
  tot = tot + 1
  if skipped == 1 { pass = pass + 1; g_p("PASS T2 license-gated: the ARR-tagged corpus was REFUSED (not mined)\n" as *u8) } else { g_p("FAIL T2 skipped=" as *u8); g_i(skipped); g_p("\n" as *u8) }
92
  // T3 real signal
  var npairs: i64 = 0
  var i: i64 = 0
  while i < n { var j: i64 = i + 1; while j < n { if cooc[i * n + j] > 0 { npairs = npairs + 1 } j = j + 1 } i = i + 1 }
  tot = tot + 1
  if npairs >= 10 { if totalhits > 0 { pass = pass + 1; g_p("PASS T3 signal: " as *u8); g_i(npairs); g_p(" distinct ingredient pairs co-occur in real recipe text\n" as *u8) } else { g_p("FAIL T3 no hits\n" as *u8) } } else { g_p("FAIL T3 too few pairs=" as *u8); g_i(npairs); g_p("\n" as *u8) }
99
  // T4 measured validation: do the corpora confirm the classic seeded pairings?
  let sa: *i64 = sys_mmap(8 * 16) as *i64
  let sb: *i64 = sys_mmap(8 * 16) as *i64
  sa[0] = "beef" as *u8 as i64;       sb[0] = "oyster" as *u8 as i64
  sa[1] = "beef" as *u8 as i64;       sb[1] = "broccoli" as *u8 as i64
  sa[2] = "beef" as *u8 as i64;       sb[2] = "onion" as *u8 as i64
  sa[3] = "chicken" as *u8 as i64;    sb[3] = "garlic" as *u8 as i64
  sa[4] = "pork" as *u8 as i64;       sb[4] = "hoisin" as *u8 as i64
  sa[5] = "shrimp" as *u8 as i64;     sb[5] = "garlic" as *u8 as i64
  sa[6] = "shrimp" as *u8 as i64;     sb[6] = "snowpea" as *u8 as i64
  sa[7] = "tofu" as *u8 as i64;       sb[7] = "sesameoil" as *u8 as i64
  sa[8] = "garlic" as *u8 as i64;     sb[8] = "ginger" as *u8 as i64
  sa[9] = "ginger" as *u8 as i64;     sb[9] = "scallion" as *u8 as i64
  sa[10] = "chili" as *u8 as i64;     sb[10] = "garlic" as *u8 as i64
  sa[11] = "mushroom" as *u8 as i64;  sb[11] = "oyster" as *u8 as i64
  sa[12] = "bellpepper" as *u8 as i64; sb[12] = "blackbean" as *u8 as i64
  sa[13] = "broccoli" as *u8 as i64;  sb[13] = "oyster" as *u8 as i64
  sa[14] = "beansprout" as *u8 as i64; sb[14] = "scallion" as *u8 as i64
  var confirmed: i64 = 0
  var sp: i64 = 0
  while sp < 15 {
      let ia: i64 = fd_index_of(world, sa[sp] as *u8)
      let ib: i64 = fd_index_of(world, sb[sp] as *u8)
      if ia >= 0 { if ib >= 0 { if cooc[ia * n + ib] > 0 { confirmed = confirmed + 1 } } }
      sp = sp + 1
  }
  // concrete allium evidence
  let gi: i64 = fd_index_of(world, "garlic" as *u8)
  let gn: i64 = fd_index_of(world, "ginger" as *u8)
  let on: i64 = fd_index_of(world, "onion" as *u8)
  let bf: i64 = fd_index_of(world, "beef" as *u8)
  g_p("  seeded classic pairs confirmed by real recipes: " as *u8); g_i(confirmed); g_p("/15\n" as *u8)
  g_p("  e.g. garlic+ginger=" as *u8); g_i(cooc[gi * n + gn])
  g_p("  onion+garlic=" as *u8); g_i(cooc[on * n + gi])
  g_p("  beef+onion=" as *u8); g_i(cooc[bf * n + on]); g_p("\n" as *u8)
  // top learned pairs (raw signal)
  let tmp: *i64 = sys_mmap(8 * n * n) as *i64
  var ti: i64 = 0; while ti < n * n { tmp[ti] = cooc[ti]; ti = ti + 1 }
  g_p("  top learned pairs:" as *u8)
  var tk: i64 = 0
  while tk < 6 {
      var bi: i64 = 0 - 1; var bj: i64 = 0 - 1; var bv: i64 = 0
      var x: i64 = 0
      while x < n { var y: i64 = x + 1; while y < n { if tmp[x * n + y] > bv { bv = tmp[x * n + y]; bi = x; bj = y } y = y + 1 } x = x + 1 }
      if bv > 0 { g_p("  " as *u8); g_name(world, bi); g_p("+" as *u8); g_name(world, bj); g_p("=" as *u8); g_i(bv); tmp[bi * n + bj] = 0; tmp[bj * n + bi] = 0 } else { tk = 6 }
      tk = tk + 1
  }
  g_p("\n" as *u8)
  tot = tot + 1
  if confirmed >= 3 { pass = pass + 1; g_p("PASS T4 validation: real recipe corpora independently CONFIRM the classic pairings (>=3 of 15) -- research, not bro science\n" as *u8) } else { g_p("FAIL T4 only " as *u8); g_i(confirmed); g_p(" seed pairs confirmed\n" as *u8) }
150
  // T5 promote durable + readable
  let written: i64 = fm_promote(RG_DUR, world, cooc)
  g_p("  promoted " as *u8); g_i(written); g_p(" learned-pair records into knowledge/store/food-\n" as *u8)
  let pq: *i64 = sys_mmap(16) as *i64
  let lq: *i64 = sys_mmap(16) as *i64
  var readback: i64 = 0
  let lkey: *u8 = sys_mmap(96)
  var lo: i64 = 0
  lo = as_append(lkey, lo, "food:pairlearned:garlic:ginger" as *u8); lkey[lo] = 0 as u8
  if ss_get(RG_DUR, lkey, pq, lq) == 1 { readback = 1 }
  // a learned record may already be durable from a prior pass (idempotent skip -> written=0); the
  // guarantee is that the learned pairs are DURABLE + READABLE, not that THIS pass wrote them.
  let lkey2: *u8 = sys_mmap(96)
  var lo2: i64 = 0
  lo2 = as_append(lkey2, lo2, "food:pairlearned:beef:ginger" as *u8); lkey2[lo2] = 0 as u8
  var readback2: i64 = 0
  if ss_get(RG_DUR, lkey2, pq, lq) == 1 { readback2 = 1 }
  tot = tot + 1
  var ok5: i64 = 1
  if readback != 1 { ok5 = 0 }
  if readback2 != 1 { ok5 = 0 }
  if ok5 == 1 { pass = pass + 1; g_p("PASS T5 promotion durable + readable (learned pairs present; this pass wrote " as *u8); g_i(written); g_p(" new, additive/idempotent)\n" as *u8) } else { g_p("FAIL T5 readback=" as *u8); g_i(readback); g_p(" readback2=" as *u8); g_i(readback2); g_p("\n" as *u8) }
173
  // T6 facts-only: the learned value is a bare integer count (no prose)
  tot = tot + 1
  var ok6: i64 = 1
  if readback == 1 {
      let b: *u8 = pq[0] as *u8
      let bl: i64 = lq[0]
      if bl == 0 { ok6 = 0 }
      var d: i64 = 0
      while d < bl { let cc: i64 = b[d] as i64; if cc < 48 { ok6 = 0 } if cc > 57 { ok6 = 0 } d = d + 1 }
  } else { ok6 = 0 }
  if ok6 == 1 { pass = pass + 1; g_p("PASS T6 facts-only: learned record is a bare ingredient-pair count, no prose stored\n" as *u8) } else { g_p("FAIL T6\n" as *u8) }
185
  // T7 LOOP CLOSED: re-open the durable world (now carrying the learned pairings) and show the engine's
  // pairing affinity for an evidence-backed-but-unseeded pair is lifted above baseline.
  let w2: *i64 = fd_world_open(RG_DUR)
  let xbf: i64 = fd_index_of(w2, "beef" as *u8)
  let xgn: i64 = fd_index_of(w2, "ginger" as *u8)
  let affbg: i64 = fd_pair_aff(w2, xbf, xgn)
  g_p("  beef+ginger affinity now=" as *u8); g_i(affbg); g_p(" (unseeded baseline=" as *u8); g_i(FOOD_AFF_BASE); g_p(", lifted by real-recipe co-occurrence)\n" as *u8)
  tot = tot + 1
  if affbg > FOOD_AFF_BASE { pass = pass + 1; g_p("PASS T7 loop closed: real recipes now move the chooser (learned pairing > baseline)\n" as *u8) } else { g_p("FAIL T7 learned evidence not reflected (aff=" as *u8); g_i(affbg); g_p(")\n" as *u8) }
195
  g_p("nx_food_recipe_gate pass=" as *u8); g_i(pass); g_p("/" as *u8); g_i(tot)
  if pass == tot { g_p(" verdict=GREEN  (pairings GROUNDED in real license-clean recipes; learned-vs-seed auditable)\n" as *u8); return 0 }
  g_p(" verdict=RED\n" as *u8)
  return 1
200}
nx_food_recipe_gate.nx source

`nx_food_recipe_gate.nx` source
