nx_dr_chain_gate.nx source
↩ module page · 131 lines · 5748 B
1// nx_dr_chain_gate.nx -- KAT + neg-controls for the end-to-end deep-research chain (DR-CHAIN).
2// Scenario: 3 groundtruth insights, 3 source docs with different coverage and cost.
3// doc0 "alpha one beta two" covers insight0+1 cost 2
4// doc1 "gamma three extra words here" covers insight2 cost 3
5// doc2 "alpha one" covers insight0 cost 1
6// Reading everything would recall 3/3 = 1000. Under budget 3 the conductor picks doc0+doc2
7// (best value) and drops doc1 -- the ONLY source for insight2 -- so recall_selected = 666.
8// That delta IS the measured cost of the opportunity-cost constraint. Neg-controls prove the
9// drop is budget-caused (unlimited budget restores 1000) and that selecting nothing scores 0.
10import "nx_dr_chain.nx"
11import "nx_dr_run.nx"
12import "nx_dr_conductor.nx"
13import "nx_dr_drbench.nx"
14import "nx_gate_verdict.nx"
15
16func main() -> i64 {
17 let ctr: *i64 = gv_ctr()
18 gv_head("nx_dr_chain -- end-to-end judge->conduct->score deep-research loop (DR-CHAIN)")
19
20 let ni: i64 = 3
21 let ndocs: i64 = 3
22
23 // ---- build the shared groundtruth insight pack
24 let ins_pack: *i64 = sys_mmap(128 * 8) as *i64
25 ins_pack[0] = ni
26 let ins_tok: *i64 = ((ins_pack as i64) + (1 + 2 * ni) * 8) as *i64
27 let s0: *u8 = "alpha one" as *u8
28 let l0: i64 = drr_tokenize(s0, drr_strlen(s0), ins_tok, 16)
29 ins_pack[1] = 0; ins_pack[1 + ni] = l0
30 let s1: *u8 = "beta two" as *u8
31 let p1: *i64 = ((ins_tok as i64) + l0 * 8) as *i64
32 let l1: i64 = drr_tokenize(s1, drr_strlen(s1), p1, 16)
33 ins_pack[2] = l0; ins_pack[2 + ni] = l1
34 let s2: *u8 = "gamma three" as *u8
35 let p2: *i64 = ((ins_tok as i64) + (l0 + l1) * 8) as *i64
36 let l2: i64 = drr_tokenize(s2, drr_strlen(s2), p2, 16)
37 ins_pack[3] = l0 + l1; ins_pack[3 + ni] = l2
38
39 // ---- build the source document pack
40 let doc_pack: *i64 = sys_mmap(128 * 8) as *i64
41 doc_pack[0] = ndocs
42 let doc_tok: *i64 = ((doc_pack as i64) + (1 + ndocs) * 8) as *i64
43 let d0: *u8 = "alpha one beta two" as *u8
44 let dl0: i64 = drr_tokenize(d0, drr_strlen(d0), doc_tok, 32)
45 doc_pack[1] = dl0
46 let d1: *u8 = "gamma three extra words here" as *u8
47 let q1: *i64 = ((doc_tok as i64) + dl0 * 8) as *i64
48 let dl1: i64 = drr_tokenize(d1, drr_strlen(d1), q1, 32)
49 doc_pack[2] = dl1
50 let d2: *u8 = "alpha one" as *u8
51 let q2: *i64 = ((doc_tok as i64) + (dl0 + dl1) * 8) as *i64
52 let dl2: i64 = drr_tokenize(d2, drr_strlen(d2), q2, 32)
53 doc_pack[3] = dl2
54
55 // ---- STAGE 1: judge every source against every insight
56 let sup: *i64 = sys_mmap(8 * 8) as *i64
57 let cov: *i64 = sys_mmap(32 * 8) as *i64
58 chain_judge_all(ins_pack, doc_pack, 600, sup, cov)
59
60 var ok1: i64 = 0
61 if sup[0] == 2 { if sup[1] == 1 { if sup[2] == 1 { ok1 = 1 } } }
62 gv_check("T1 per-source supported counts 2/1/1", ok1, ctr)
63
64 var ok2: i64 = 0
65 if cov[0] == 1 { if cov[2] == 0 { if cov[5] == 1 { ok2 = 1 } } }
66 gv_check("T2 coverage matrix spot-checks", ok2, ctr)
67
68 // ---- recall if we could read EVERY source
69 let allsel: *i64 = sys_mmap(8 * 8) as *i64
70 allsel[0] = 1; allsel[1] = 1; allsel[2] = 1
71 let allcov: *i64 = sys_mmap(8 * 8) as *i64
72 chain_sel_cov(cov, allsel, ndocs, ni, allcov)
73 let recall_all: i64 = dr_frac(allcov, ni)
74 var ok3: i64 = 0
75 if recall_all == 1000 { ok3 = 1 }
76 gv_check("T3 recall_all = 1000 (every source read)", ok3, ctr)
77
78 // ---- STAGE 2: conduct (verify-yield -> Elo tournament -> opp-cost dispatch) at budget 3
79 let total: *i64 = sys_mmap(8 * 8) as *i64
80 total[0] = ni; total[1] = ni; total[2] = ni
81 let cost: *i64 = sys_mmap(8 * 8) as *i64
82 cost[0] = 2; cost[1] = 3; cost[2] = 1
83 let out: *i64 = sys_mmap((5 * 3 + 1) * 8) as *i64
84 let cnt: i64 = cond_run(sup, total, cost, ndocs, 3, out)
85 let ord: *i64 = ((out as i64) + ndocs * 24) as *i64
86 let sel: *i64 = ((out as i64) + ndocs * 32) as *i64
87 let spent: i64 = out[5 * 3]
88
89 var ok4: i64 = 0
90 if cnt == 2 { if spent == 3 { ok4 = 1 } }
91 gv_check("T4 dispatch selects 2 sources spends 3", ok4, ctr)
92
93 var ok5: i64 = 0
94 if ord[0] == 0 { ok5 = 1 }
95 gv_check("T5 best-value source leads the ranking", ok5, ctr)
96
97 // ---- STAGE 3: score what was actually selected
98 let selcov: *i64 = sys_mmap(8 * 8) as *i64
99 chain_sel_cov(cov, sel, ndocs, ni, selcov)
100 let recall_sel: i64 = dr_frac(selcov, ni)
101 var ok6: i64 = 0
102 if recall_sel == 666 { ok6 = 1 }
103 gv_check("T6 recall_selected = 666 under budget", ok6, ctr)
104
105 var ok7: i64 = 0
106 if recall_sel < recall_all { ok7 = 1 }
107 gv_check("T7 budget constraint measurably costs recall", ok7, ctr)
108
109 // ---- T8 NEG-CONTROL: with an unlimited budget the loss disappears (drop was budget-caused)
110 let out2: *i64 = sys_mmap((5 * 3 + 1) * 8) as *i64
111 let cnt2: i64 = cond_run(sup, total, cost, ndocs, 100, out2)
112 let sel2: *i64 = ((out2 as i64) + ndocs * 32) as *i64
113 let selcov2: *i64 = sys_mmap(8 * 8) as *i64
114 chain_sel_cov(cov, sel2, ndocs, ni, selcov2)
115 var ok8: i64 = 0
116 if cnt2 == 3 { if dr_frac(selcov2, ni) == 1000 { ok8 = 1 } }
117 gv_check("T8 neg-control unlimited budget restores 1000", ok8, ctr)
118
119 // ---- T9 NEG-CONTROL: selecting nothing recalls nothing
120 let nosel: *i64 = sys_mmap(8 * 8) as *i64
121 nosel[0] = 0; nosel[1] = 0; nosel[2] = 0
122 let nocov: *i64 = sys_mmap(8 * 8) as *i64
123 chain_sel_cov(cov, nosel, ndocs, ni, nocov)
124 var ok9: i64 = 0
125 if dr_frac(nocov, ni) == 0 { ok9 = 1 }
126 gv_check("T9 neg-control nothing selected recalls 0", ok9, ctr)
127
128 let rc: i64 = gv_verdict("DR-CHAIN", ctr, "judge->conduct->score end-to-end + budget-cost measurement, neg-controls")
129 sys_exit(rc)
130 return rc
131}