nx_ncf_recur_gate.nx source

1// nx_ncf_recur_gate.nx -- X-AUT-NCF-001 RUNG 6 (GENERALIZATION, not another special case): synthesize an 2// ORDER-k LINEAR RECURRENCE from ONE parameterized construct (companion / shift-register form). Instead of 3// hand-authoring three-state, four-state, ... as separate rungs, this is a SINGLE construct parameterized by 4// order k -- it SUBSUMES the two-state rung (k=2 = Fibonacci) and covers ANY order (k=3 Tribonacci, k=4 5// Tetranacci, ...). That is "build intelligence, not special-cases" + a real autonomy point: the team now 6// covers an UNBOUNDED family (every k-nacci / constant-coeff linear recurrence) without a per-order rung. 7// T1 NEG-CONTROL: the two-state rung (k=2 max) FAILS on Tribonacci -> a higher, general order is necessary. 8// T2 SYNTHESIS: the general construct finds Tribonacci at k=3 (c=1,1,1). 9// T3 MATERIALIZE+GOD-BUILD+run HELD-OUT {8->24, 9->44} -> 24044. 10// T4 SUBSUMPTION: the SAME construct fits Fibonacci at k=2 -> it generalizes rung 5 (one construct, many). 11// T5 UNBOUNDED: the SAME construct fits Tetranacci at k=4 -> any order from one parameterized rung. 12// expect_exit: 0 license_tier: ORIGINAL 13import "nx_ncf_synth.nx" 14import "nx_syscalls.nx" 15 16func main() -> i64 { 17 ncf_w("=== nx_ncf_recur: GENERALIZED order-k linear recurrence (X-AUT-NCF-001 rung 6) -- ONE construct, any order ===\n" as *u8) 18 var pass: i64=0; var total: i64=0 19 20 // Tribonacci (seed 0,0,1): train x=0..7 {0,0,1,1,2,4,7,13}, HELD-OUT {8->24, 9->44}. 21 let xs: *i64=sys_mmap(128) as *i64; let ys: *i64=sys_mmap(128) as *i64 22 xs[0]=0; xs[1]=1; xs[2]=2; xs[3]=3; xs[4]=4; xs[5]=5; xs[6]=6; xs[7]=7 23 ys[0]=0; ys[1]=0; ys[2]=1; ys[3]=1; ys[4]=2; ys[5]=4; ys[6]=7; ys[7]=13 24 let n: i64=8 25 26 let sp: *i64=sys_mmap(8) as *i64; sp[0]=0-1 27 let sfd: i64=sys_openat_wr(NCF_RESULT,420); if sfd>=0 { sys_write(sfd,sp as *u8,8); sys_close(sfd) } 28 29 // T1: the two-state rung (rung 5, order-2 max) FAILS on Tribonacci (order-3). 30 let tform: *i64=sys_mmap(64) as *i64 31 let twostate: i64=ncf_search_loop4(xs,ys,n,tform) 32 total=total+1; if twostate==0 { pass=pass+1; ncf_w(" [PASS] " as *u8) } else { ncf_w(" [FAIL] " as *u8) } 33 ncf_w("T1 NEG-CONTROL: two-state rung (order-2 max) FAILS on Tribonacci -> general order necessary, twostate_found=" as *u8); ncf_n(twostate); ncf_w("\n" as *u8) 34 35 // T2: the GENERAL construct synthesizes Tribonacci at k=3. 36 let form: *i64=sys_mmap(160) as *i64 37 let s: i64=ncf_search_recur(xs,ys,n,form) 38 total=total+1; if s==1 { if form[0]==3 { pass=pass+1; ncf_w(" [PASS] " as *u8) } else { ncf_w(" [FAIL] " as *u8) } } else { ncf_w(" [FAIL] " as *u8) } 39 ncf_w("T2 SYNTHESIS: general recurrence FOUND order k=" as *u8); ncf_n(form[0]); ncf_w("; a(n)=" as *u8); ncf_n(form[1]); ncf_w("a(n-3)+" as *u8); ncf_n(form[2]); ncf_w("a(n-2)+" as *u8); ncf_n(form[3]); ncf_w("a(n-1) for Tribonacci\n" as *u8) 40 41 // T3: MATERIALIZE -> GOD-BUILD -> run HELD-OUT -> verify (Trib(8)=24, Trib(9)=44 -> 24044). 42 var emitted: i64=0; if s==1 { if ncf_emit(6,form,8,9,1000)==0 { emitted=1 } } 43 var built: i64=0; if emitted==1 { if ncf_god_build(NCF_NAME)==0 { built=1 } } 44 let produced: i64=ncf_read(NCF_RESULT) 45 total=total+1; if produced==24044 { pass=pass+1; ncf_w(" [PASS] " as *u8) } else { ncf_w(" [FAIL] " as *u8) } 46 ncf_w("T3 MATERIALIZE+GOD-BUILD: synthesized order-k recurrence compiled (nx_cc->nxasm, no gcc) + ran HELD-OUT -> produced=" as *u8); ncf_n(produced); ncf_w(" (expect 24044 = Trib8*1000+Trib9)\n" as *u8) 47 48 // T4: SUBSUMPTION -- the SAME construct fits Fibonacci at k=2 (it generalizes the two-state rung). 49 let xf: *i64=sys_mmap(128) as *i64; let yf: *i64=sys_mmap(128) as *i64 50 xf[0]=0; xf[1]=1; xf[2]=2; xf[3]=3; xf[4]=4; xf[5]=5; xf[6]=6; xf[7]=7 51 yf[0]=0; yf[1]=1; yf[2]=1; yf[3]=2; yf[4]=3; yf[5]=5; yf[6]=8; yf[7]=13 52 let ff: *i64=sys_mmap(160) as *i64 53 let sf: i64=ncf_search_recur(xf,yf,8,ff) 54 total=total+1; if sf==1 { if ff[0]==2 { pass=pass+1; ncf_w(" [PASS] " as *u8) } else { ncf_w(" [FAIL] " as *u8) } } else { ncf_w(" [FAIL] " as *u8) } 55 ncf_w("T4 SUBSUMPTION: SAME construct fits Fibonacci at k=" as *u8); ncf_n(ff[0]); ncf_w(" -> generalizes rung 5 (the two-state special case)\n" as *u8) 56 57 // T5: UNBOUNDED -- the SAME construct fits Tetranacci at k=4 (any order from one parameterized rung). 58 let xt: *i64=sys_mmap(128) as *i64; let yt: *i64=sys_mmap(128) as *i64 59 xt[0]=0; xt[1]=1; xt[2]=2; xt[3]=3; xt[4]=4; xt[5]=5; xt[6]=6; xt[7]=7 60 yt[0]=0; yt[1]=0; yt[2]=0; yt[3]=1; yt[4]=1; yt[5]=2; yt[6]=4; yt[7]=8 61 let ft: *i64=sys_mmap(160) as *i64 62 let st: i64=ncf_search_recur(xt,yt,8,ft) 63 total=total+1; if st==1 { if ft[0]==4 { pass=pass+1; ncf_w(" [PASS] " as *u8) } else { ncf_w(" [FAIL] " as *u8) } } else { ncf_w(" [FAIL] " as *u8) } 64 ncf_w("T5 UNBOUNDED: SAME construct fits Tetranacci at k=" as *u8); ncf_n(ft[0]); ncf_w(" -> any order from ONE parameterized construct (no per-order rung)\n" as *u8) 65 66 ncf_w("\n HONEST SCOPE: covers CONSTANT-COEFFICIENT linear recurrences of order k<=4, coeffs in {0,1,2} (Fibonacci/Lucas/Pell/Tribonacci/Tetranacci). NONLINEAR recurrences (a(n)=a(n-1)^2) + non-constant coeffs still escalate = the next frontier. The win: ONE construct replaced the per-order special-case ladder = build intelligence, not special-cases.\n" as *u8) 67 ncf_w("NCF-RECUR verdict=" as *u8) 68 if pass==total { ncf_w("GREEN passes=" as *u8); ncf_n(pass); ncf_w("/" as *u8); ncf_n(total); ncf_w(" -- ONE parameterized construct covers the whole k-order linear-recurrence family: X-AUT-NCF-001 rung 6 (generalization)\n" as *u8); sys_exit(0); return 0 } 69 ncf_w("RED passes=" as *u8); ncf_n(pass); ncf_w("/" as *u8); ncf_n(total); ncf_w("\n" as *u8); sys_exit(1); return 1 70}