nx_evolution_oracle_gate.nx source

1import "nx_gate_gn.nx" 2import "nx_gate_base.nx" 3// nx_evolution_oracle_gate.nx -- R10: the LINEAGE LIAR-KILLER (operator's insight). Use what is already 4// built FROM GOD as the benchmark for whether a fresh generation is EVOLVING WELL. For a generated 5// capability: find the SAME behavior in the lineage (the god-rooted best-so-far). Compare quality 6// (op-list length = efficiency; shorter is better, correctness required): 7// SUPERIOR (shorter, correct) -> evolving well; ADOPT it (the lineage improves). 8// EQUAL -> fine. 9// INFERIOR (longer) -> we DEFINITELY missed evolutions; do NOT adopt; BACKTRACK -- revisit 10// the parents back to GOD (the lineage holds the efficient ancestor) and 11// re-scaffold properly. 12// NEW behavior -> a genuine new evolution; adopt + extend the lineage. 13// This is a LIAR-KILLER: a scaffold that "reaches the target" but is WORSE than what we already built is 14// a REGRESSION dressed as progress -- a naive "did it work?" passes it; this catches it. Sovereign. 15// license_tier: ORIGINAL [[feedback-no-wave-measured-exceed]] [[project-genesis-genealogy-2026-06-16]] 16import "nx_syscalls.nx" 17 18const O_NPROBE: i64 = 4 19const O_MAXOPS: i64 = 8 20const O_MAXLIN: i64 = 16 21 22 23func grow(name: *u8, ok: i64) -> i64 { if ok==1 { gw(" PASS " as *u8) } else { gw(" FAIL " as *u8) } gw(name); gw(" 24" as *u8); return ok } 25func o_sig(ops: *i64, args: *i64, len: i64, sig: *i64) -> i64 { 26 var p: i64 = 0 27 while p < O_NPROBE { 28 var acc: i64 = p; var k: i64 = 0 29 while k < len { let op: i64 = ops[k]; if op==0 { acc=acc+args[k] } if op==1 { acc=acc*args[k] } if op==2 { acc=acc*acc } k=k+1 } 30 sig[p] = acc; p = p + 1 31 } 32 return 0 33} 34func o_sigeq(a: *i64, b: *i64) -> i64 { var p: i64=0; while p<O_NPROBE { if a[p]!=b[p] { return 0 } p=p+1 } return 1 } 35 36// lineage store: per entry a sig + the god-rooted best op-list + its length. 37// find the lineage index whose sig matches `sig`, or -1. 38func lin_find(lin_sig: *i64, nlin: i64, sig: *i64) -> i64 { 39 var i: i64 = 0 40 while i < nlin { let e: *i64 = ((lin_sig as i64)+i*O_NPROBE*8) as *i64; if o_sigeq(e, sig)==1 { return i } i = i + 1 } 41 return 0 - 1 42} 43// store/overwrite lineage entry idx with (sig, ops, len). 44func lin_put(lin_sig: *i64, lin_len: *i64, lin_ops: *i64, idx: i64, sig: *i64, ops: *i64, args: *i64, len: i64) -> i64 { 45 var p: i64 = 0; while p < O_NPROBE { lin_sig[idx*O_NPROBE+p]=sig[p]; p=p+1 } 46 lin_len[idx] = len 47 var k: i64 = 0; while k < len { lin_ops[idx*O_MAXOPS+k]=ops[k]; k=k+1 } // (args omitted from store; len is the quality metric) 48 return 0 49} 50 51// GRADE a candidate vs the god-rooted lineage. returns 1=SUPERIOR 0=EQUAL -1=INFERIOR 2=NEW. 52// on SUPERIOR/NEW updates the lineage (evolution adopted). on INFERIOR sets bt_len[0]=the god-rooted best length. 53func o_grade(lin_sig: *i64, lin_len: *i64, lin_ops: *i64, nlin_p: *i64, ops: *i64, args: *i64, len: i64, bt_len: *i64) -> i64 { 54 let sig: *i64 = sys_mmap(8*O_NPROBE) as *i64 55 o_sig(ops, args, len, sig) 56 let nlin: i64 = nlin_p[0] 57 let idx: i64 = lin_find(lin_sig, nlin, sig) 58 if idx < 0 { 59 lin_put(lin_sig, lin_len, lin_ops, nlin, sig, ops, args, len) 60 nlin_p[0] = nlin + 1 61 return 2 62 } 63 let best: i64 = lin_len[idx] 64 if len < best { lin_put(lin_sig, lin_len, lin_ops, idx, sig, ops, args, len); return 1 } 65 if len == best { return 0 } 66 bt_len[0] = best 67 return 0 - 1 68} 69 70func main(argc: i64, argv: *i64) -> i64 { 71 gw("=== R10 LINEAGE LIAR-KILLER: grade evolution vs what's already built FROM GOD ===\n" as *u8) 72 let lin_sig: *i64 = sys_mmap(8*O_MAXLIN*O_NPROBE) as *i64 73 let lin_len: *i64 = sys_mmap(8*O_MAXLIN) as *i64 74 let lin_ops: *i64 = sys_mmap(8*O_MAXLIN*O_MAXOPS) as *i64 75 let nlin: *i64 = sys_mmap(16) as *i64 76 nlin[0] = 0 77 let to: *i64 = sys_mmap(8*O_MAXOPS) as *i64 78 let ta: *i64 = sys_mmap(8*O_MAXOPS) as *i64 79 let sig: *i64 = sys_mmap(8*O_NPROBE) as *i64 80 let bt: *i64 = sys_mmap(16) as *i64 81 // SEED the lineage (already built, god-rooted): x^2=[square] len1 ; 4x=[*2,*2] len2 (a suboptimal-known) 82 to[0]=2; ta[0]=0; o_sig(to,ta,1,sig); lin_put(lin_sig,lin_len,lin_ops,nlin[0],sig,to,ta,1); nlin[0]=nlin[0]+1 83 to[0]=1; ta[0]=2; to[1]=1; ta[1]=2; o_sig(to,ta,2,sig); lin_put(lin_sig,lin_len,lin_ops,nlin[0],sig,to,ta,2); nlin[0]=nlin[0]+1 84 gw("seeded lineage: x^2=[square] len1, 4x=[*2,*2] len2\n\n" as *u8) 85 86 // C1 INFERIOR: x^2 via [square,+1,-1] len3 (correct behavior, wasteful) -> vs lineage [square] len1 87 to[0]=2; ta[0]=0; to[1]=0; ta[1]=1; to[2]=0; ta[2]=0-1 88 bt[0]=0 89 let v1: i64 = o_grade(lin_sig,lin_len,lin_ops,nlin, to,ta,3, bt) 90 gw(" C1 x^2 via [square,+1,-1] len3 -> verdict=" as *u8); gn(v1) 91 if v1 == 0-1 { gw(" INFERIOR -> BACKTRACK to god-rooted form len=" as *u8); gn(bt[0]); gw(" (revisit parents to god, re-scaffold minimal)\n" as *u8) } else { gw("\n" as *u8) } 92 93 // C2 SUPERIOR: 4x via [*4] len1 -> vs lineage [*2,*2] len2 -> shorter -> adopt 94 to[0]=1; ta[0]=4 95 let v2: i64 = o_grade(lin_sig,lin_len,lin_ops,nlin, to,ta,1, bt) 96 gw(" C2 4x via [*4] len1 -> verdict=" as *u8); gn(v2); if v2==1 { gw(" SUPERIOR -> ADOPT (lineage 4x improves 2->1, evolving well)\n" as *u8) } else { gw("\n" as *u8) } 97 98 // C3 EQUAL: x^2 via [square] len1 99 to[0]=2; ta[0]=0 100 let v3: i64 = o_grade(lin_sig,lin_len,lin_ops,nlin, to,ta,1, bt) 101 gw(" C3 x^2 via [square] len1 -> verdict=" as *u8); gn(v3); if v3==0 { gw(" EQUAL -> fine\n" as *u8) } else { gw("\n" as *u8) } 102 103 // C4 NEW: x^2+5 via [square,+5] len2 -> no lineage entry -> new evolution 104 to[0]=2; ta[0]=0; to[1]=0; ta[1]=5 105 let v4: i64 = o_grade(lin_sig,lin_len,lin_ops,nlin, to,ta,2, bt) 106 gw(" C4 x^2+5 via [square,+5] len2 -> verdict=" as *u8); gn(v4); if v4==2 { gw(" NEW -> adopt as a genuine new evolution\n" as *u8) } else { gw("\n" as *u8) } 107 108 // verify the INFERIOR C1 was NOT adopted: lineage x^2 is STILL len1 (the god-rooted form held). 109 to[0]=2; ta[0]=0; o_sig(to,ta,1,sig) 110 let xidx: i64 = lin_find(lin_sig, nlin[0], sig) 111 var x2len: i64 = 0-1; if xidx >= 0 { x2len = lin_len[xidx] } 112 gw("\n post-check: lineage x^2 best length = " as *u8); gn(x2len); gw(" (the inferior C1 was REJECTED, god-form held)\n" as *u8) 113 114 // ---- GATE (no-fake-green) ---- 115 var t1: i64 = 0; if v2 == 1 { t1 = 1 } // SUPERIOR detected (evolving well) 116 var t2: i64 = 0; if v3 == 0 { t2 = 1 } // EQUAL detected 117 var t3: i64 = 0; if v1 == 0-1 { if bt[0] == 1 { t3 = 1 } } // INFERIOR caught + BACKTRACK returns the god-rooted len1 118 var t4: i64 = 0; if v4 == 2 { t4 = 1 } // NEW behavior adopted as evolution 119 var t5: i64 = 0; if x2len == 1 { t5 = 1 } // NO-FAKE: the inferior regression was NOT adopted 120 121 gw("T1 superior=" as *u8); gn(t1); gw(" T2 equal=" as *u8); gn(t2); gw(" T3 inferior+backtrack-to-god=" as *u8); gn(t3); gw(" T4 new=" as *u8); gn(t4); gw(" T5 regression-rejected=" as *u8); gn(t5); gw("\n" as *u8) 122 123 var green: i64 = 0 124 if t1==1 { if t2==1 { if t3==1 { if t4==1 { if t5==1 { green = 1 } } } } } 125 if green == 1 { 126 gw("VERDICT: GREEN -- the lineage (from god) grades evolution: superior ADOPTED, inferior CAUGHT + backtracked to god, new ADOPTED, regression REJECTED. The liar-killer works.\n" as *u8) 127 gw("WIRE-IN: every scaffolded capability is graded vs its god-rooted ancestor; inferior -> revisit parents to god + re-scaffold. (Toy domain; same mechanism applies to the real genesis_lineage.)\n" as *u8) 128 sys_exit(0); return 0 129 } 130 gw("VERDICT: RED\n" as *u8); sys_exit(1); return 1 131}