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

↩ module page · 201 lines · 11973 B
1// nx_gamefeel_oracle_gate.nx -- FEEL PROVES AGAINST BANKED REFERENCES (operator 2026-08-02:
2// "mine the modding communities and published work as oracles to SKIP guess-and-test").
3// The crypto lane's KAT law applied to game feel: every tunable the engine ships must sit
4// inside a band banked in ../knowledge/gamefeel_oracle.conf WITH its sources named; a tunable
5// whose row is MISSING is RED by construction (no unbanked numbers), and every compare is
6// CROSS-MULTIPLIED (the banked truncation law). Values are read from the LIVE symbols the
7// engine itself uses (wc_spec arena + the lib/engine constants) -- the gate cannot drift
8// from the game because they share one definition.
9// license_tier: ORIGINAL   No hw writes (Rule 26).   expect_exit: 0
10import "nx_wasm_craft.nx"
11import "nx_gate_verdict.nx"
12import "nx_oracleband_lib.nx"
13const GF_MAGIC_4096: i64 = 4096
14
15const GF_CONF: *u8 = "../knowledge/gamefeel_oracle.conf"
16
17
18// DELEGATED to nx_oracleband_lib. Returns rows, -1 unreadable, and now -2 = the table outgrew the row cap.
19// The old private loader capped at 32 rows SILENTLY, which would have read a grown table as a PREFIX and
20// turned every row past the cap into a "missing row" -- i.e. an honest-looking RED caused by the reader.
21func gf_load() -> i64 { return ob_load("../knowledge/gamefeel_oracle.conf\x00" as *u8) }
22
23func gf_eq(a: *u8, b: *u8) -> i64 { return ob_eq(a, b) }
24// find a band; returns row index or -1 (a MISSING row must read as failure, never as pass)
25func gf_find(key: *u8) -> i64 { return ob_find(key) }
26// one banded check: value inside [min,max] of its cited row (all integer, no division)
27func gf_band(name: *u8, key: *u8, val: i64, ctr: *i64) -> i64 { return ob_band(name, key, val, ctr) }
28
29func main() -> i64 {
  let ctr: *i64 = gv_ctr()
  gv_head("nx_gamefeel_oracle gate -- every feel tunable inside a BANKED, CITED reference band" as *u8)
  let nrows: i64 = gf_load()
  if nrows <= 0 {
      // two DIFFERENT failures, two messages (the ambiguous-return class bit this very
      // gate on its first run: a parser bug read as "cannot read")
      if nrows < 0 { gv_puts("  cannot READ ../knowledge/gamefeel_oracle.conf\n" as *u8) }
      if nrows == 0 { gv_puts("  table read but ZERO rows parsed\n" as *u8) }
      gv_check("oracle table present" as *u8, 0, ctr)
      let rcx: i64 = gv_verdict("GAMEFEEL-ORACLE" as *u8, ctr, "no table" as *u8)
      sys_exit(rcx)
      return rcx
  }
  // live values from the ENGINE'S OWN definitions (one arena, spec identity 0)
  let base: i64 = sys_mmap(CRAFT_TOTAL + GF_MAGIC_4096) as i64
  wc_spec(base, 0)
  let sp: *i64 = wsp(base)
  gf_band("day length (s)" as *u8, "day_len_s" as *u8, sp[P_DAYLEN]/60, ctr)
  gf_band("crop roll cadence (s)" as *u8, "crop_roll_s" as *u8, sp[P_GROWE]/60, ctr)
  // THE CHEST BAND. This gate no longer re-derives K and C. It calls the SHIPPING derivation
  // (nx_softbind sb_k_up / sb_c_for), so the gate and the game cannot drift apart. The version
  // before this one carried its OWN copy of four constants and would have gone on passing while
  // the game moved underneath it -- a duplicate ruler, caught only because the constants were
  // finally deleted. A gate that re-implements its subject's arithmetic is not measuring it.
  var f: i64 = 0
  var kall: i64 = 1
  var zall: i64 = 1
  while f <= SB_FIRM_MAX {
      let fnm: i64 = sb_fn_mhz(f)
      let K: i64 = sb_k_up(fnm)
      let C: i64 = sb_c_for(K)
      // The SOFT branch is the quantity comparable to a single-spring stiffness, so it is what
      // chest_k_q10 judges. The stiff branch (cai2018, ~9x) has no row of its own and is not
      // asserted against one -- inventing a band for it would be taste wearing a citation.
      let r: i64 = gf_find("chest_k_q10" as *u8)
      if r < 0 { kall = 0 }
      if r >= 0 {
          if K < ob_lo(r) { kall = 0 }
          if K > ob_hi(r) { kall = 0 }
      }
      // zeta band, CROSS-MULTIPLIED: lo^2*4096K <= C^2*10^6 <= hi^2*4096K.
      // JUDGED AGAINST tissue_zeta_permil (the measured HUMAN), not chest_zeta_permil (the
      // modding-community blend band). Those two rows describe the same dimensionless quantity
      // and DO NOT OVERLAP -- 100..300 against 350..600 -- so one of them had to be chosen and
      // the reason is recorded rather than silently resolved: the conf itself says the ringdown
      // probe is what licenses comparing a tunable to a subject row, and on 2026-08-25 that
      // probe reported our XPBD plant at fn=4137 mhz zeta=480 permil, inside BOTH subject
      // bands. A game-convention band is what we are here to exceed, not to conform to.
      let rz: i64 = gf_find("tissue_zeta_permil" as *u8)
      if rz < 0 { zall = 0 }
      if rz >= 0 {
          let lo: i64 = ob_lo(rz)
          let hi: i64 = ob_hi(rz)
          let lhs: i64 = C*C*1000000
          if lhs < lo*lo*4096*K { zall = 0 }
          if lhs > hi*hi*4096*K { zall = 0 }
      }
      f = f + 1
  }
  gv_check("chest K: every bred firmness stop inside the cited band (SHIPPING derivation, not a copy)" as *u8, kall, ctr)
  gv_check("chest zeta: every stop inside the MEASURED-HUMAN envelope (cross-multiplied)" as *u8, zall, ctr)
  // ANTI-DRIFT: the band endpoints COMPILED INTO nx_softbind must equal the conf rows they cite.
  // Without this, an edit to either side is silent and the derivation keeps its old numbers
  // while still claiming the citation. This is the tooth that makes the citation load-bearing.
  // Now ob_pin, the extracted general form: assert a COMPILED constant equals its cited row. It also
  // PRINTS both sides, so a drift shows the two numbers instead of a bare FAIL. This is the one tooth
  // that makes a citation load-bearing, and it now lives in the lib for every organ, not just this gate.
  ob_pin("nx_softbind's compiled fn band EQUALS conf tissue_fn_mhz (citation is load-bearing)" as *u8,
         "tissue_fn_mhz" as *u8, SB_FN_LO_MHZ, SB_FN_HI_MHZ, ctr)
  var anisook: i64 = 1
  let rap: i64 = gf_find("tissue_aniso_ap_permil" as *u8)
  let rml: i64 = gf_find("tissue_aniso_ml_permil" as *u8)
  if rap < 0 { anisook = 0 }
  if rml < 0 { anisook = 0 }
  if rap >= 0 {
      if SB_ANISO_AP_PERMIL < ob_lo(rap) { anisook = 0 }
      if SB_ANISO_AP_PERMIL > ob_hi(rap) { anisook = 0 }
  }
  if rml >= 0 {
      if SB_ANISO_ML_PERMIL < ob_lo(rml) { anisook = 0 }
      if SB_ANISO_ML_PERMIL > ob_hi(rml) { anisook = 0 }
  }
  gv_check("compiled AP/ML anisotropy inside the cited mills2025 bands" as *u8, anisook, ctr)
  // ===== THE cai2018 ROWS BECOME LOAD-BEARING (adjudication 2026-08-25) ==================
  // Until today the four cai2018 rows in the conf were read by NO TOOTH. SB_KUP_REF and
  // SB_KDN_REF in nx_softbind cited them in a COMMENT and nothing checked the citation --
  // precisely the silent drift ob_pin was extracted to stop, applied to tissue_fn_mhz and
  // never to its siblings. A law applied in one place and not its sibling is half a law.
  // These two bands do NOT invent a row for the stiff branch (this gate has always refused
  // to do that): they judge the two COMPILED reference constants against the two banked
  // rows they already claim to derive from.
  gf_band("softbind SB_KUP_REF (cai2018 k_a, soft branch)" as *u8, "tissue_k_up_n_per_m" as *u8, SB_KUP_REF, ctr)
  gf_band("softbind SB_KDN_REF (cai2018 k_b, stiff branch)" as *u8, "tissue_k_down_n_per_m" as *u8, SB_KDN_REF, ctr)
  // THE SHIPPED ASYMMETRY RATIO, judged against the ratio the two CITED bands IMPLY. Derived
  // from two banked rows, never a new band. CROSS-MULTIPLIED (the banked truncation law) so
  // an integer division cannot silently pass a value:
  //   ratio_tenths*hi(k_up) >= lo(k_down)*10   and   ratio_tenths*lo(k_up) <= hi(k_down)*10
  // WHY THIS TOOTH EXISTS: PMC10116697 reports "a bimodular model was unnecessary", which
  // reads as a licence to delete the sign test in sd_step_axq. The conf adjudication records
  // why that reading is wrong (subject mismatch: 1-cm excised cubes with the suspensory
  // ligaments cut away cannot exhibit an organ-level tension-only suspension, and the same
  // paper's Methods AFFIRM tension-compression asymmetry via an odd function of strain). This
  // tooth is what stops the deletion happening SILENTLY if someone reads only the Discussion.
  let rku: i64 = gf_find("tissue_k_up_n_per_m" as *u8)
  let rkd: i64 = gf_find("tissue_k_down_n_per_m" as *u8)
  let fn0: i64 = sb_fn_mhz(0)
  let kup0: i64 = sb_k_up(fn0)
  let kdn0: i64 = sb_k_dn(fn0)
  // FIXTURE REACHED THE CONDITION, asserted BEFORE the outcome: both rows must resolve and the
  // soft branch must be non-zero, or the ratio below is a division by zero wearing a verdict.
  var reached: i64 = 1
  if rku < 0 { reached = 0 }
  if rkd < 0 { reached = 0 }
  if kup0 <= 0 { reached = 0 }
  gv_check("asym-fixture-reached-the-condition: both cai2018 rows resolve and sb_k_up>0" as *u8, reached, ctr)
  var asymok: i64 = 0
  var negasym: i64 = 0
  if reached == 1 {
      let rt: i64 = kdn0*10/kup0
      gv_puts("  shipped asymmetry sb_k_dn/sb_k_up = " as *u8)
      gv_num(rt)
      gv_puts(" tenths vs cited implied [" as *u8)
      gv_num(ob_lo(rkd)*10/ob_hi(rku))
      gv_puts(".." as *u8)
      gv_num(ob_hi(rkd)*10/ob_lo(rku))
      gv_puts("]\n" as *u8)
      asymok = 1
      if rt*ob_hi(rku) < ob_lo(rkd)*10 { asymok = 0 }
      if rt*ob_lo(rku) > ob_hi(rkd)*10 { asymok = 0 }
      // NEG-CONTROL: a SYMMETRIC plant -- exactly the change the bimodular objection would
      // motivate -- scores 10 tenths and MUST be refused by the same cited bound. Without this
      // the tooth above is decoration: a band wide enough to admit 10 could never detect the
      // deletion it exists to detect.
      if 10*ob_hi(rku) < ob_lo(rkd)*10 { negasym = 1 }
  }
  gv_check("shipped asymmetry ratio inside the ratio the two CITED rows imply (cross-multiplied, DERIVED not invented)" as *u8, asymok, ctr)
  gv_check("neg-control-symmetric-plant-is-REFUSED-by-the-cited-asymmetry-ratio" as *u8, negasym, ctr)
  // NEG-CONTROL: the retired hand-tuned plant must FAIL the band it was shipped under. If this
  // passes, the bands are too wide to discriminate and every green above is decoration.
  var negfired: i64 = 0
  let oldK: i64 = 85
  let oldC: i64 = 110
  if rz >= 0 {
      let lo2: i64 = ob_lo(rz)
      if oldC*oldC*1000000 < lo2*lo2*4096*oldK { negfired = 1 }
  }
  gv_check("neg-control-retired-tuned-plant-is-REFUSED-by-the-measured-human-envelope" as *u8, negfired, ctr)
  gf_band("hair K (per-1024)" as *u8, "hair_k_q10" as *u8, SB_K_HAIR, ctr)
  gf_band("gait bob (q8)" as *u8, "gait_bob_q8" as *u8, WC_GAIT_BOB_Q8, ctr)
  gf_band("step ease up (q8/t)" as *u8, "step_ease_up_q8" as *u8, WC_STEP_EASE_UP, ctr)
  gf_band("night start (eighths)" as *u8, "night_x8" as *u8, WC_NIGHT_X8, ctr)
  // BITE (non-vacuity): a deliberately out-of-band value must FAIL, an in-band one must PASS
  let rb: i64 = gf_find("gait_bob_q8" as *u8)
  var bad: i64 = 0
  var good: i64 = 0
  if rb >= 0 {
      let bmn: i64 = ob_lo(rb)
      let bmx: i64 = ob_hi(rb)
      // out-of-band probe must FIRE (bad=1); the band's own min must stay SILENT (good=0)
      let probe: i64 = bmx + 100
      if probe < bmn { bad = 1 }
      if probe > bmx { bad = 1 }
      var silent: i64 = 1
      if bmn < bmn { silent = 0 }
      if bmn > bmx { silent = 0 }
      good = 1 - silent
  }
  gv_bite("band check bites out-of-band and passes in-band" as *u8, bad, good, ctr)
  let rc: i64 = gv_verdict("GAMEFEEL-ORACLE" as *u8, ctr, "feel is cited, never tasted" as *u8)
  sys_exit(rc)
  return rc
201}
nx_gamefeel_oracle_gate.nx source

`nx_gamefeel_oracle_gate.nx` source
