nx_arbitration.nx source

1// nx_arbitration.nx -- MANHEIM-BUILD-L3 (assurance/trust): the ARBITRATION ELIGIBILITY engine (Manheim / 2// NAAA-class dispute resolution), the rules that decide whether a buyer's post-sale claim is arbitrable. 3// Sovereign (nx_cc->nxasm, no gcc), deterministic. 4// 5// WHY IT MATTERS: arbitration disputes are a major friction + cost in wholesale. The failure mode of an 6// opaque / single-factor process is INCONSISTENCY and OVER-ADMISSION -- a claim that is expensive but 7// time-barred, sold as-is, or in a non-arbitrable category gets let through by a "is it expensive?" 8// heuristic, creating cost + unfairness. Correct eligibility is CONJUNCTIVE: every condition must hold. 9// 10// ENGINE (auditable -- returns the precise failing reason): 11// ELIGIBLE iff ALL: repair_cost >= threshold AND filed within window AND arbitrable category AND NOT as-is. 12// reason codes: 0=eligible 1=below_threshold 2=window_expired 3=non_arbitrable_category 4=as_is_sale 13// naive baseline = checks ONLY the dollar threshold (the over-admitting heuristic). 14// 15// ===== S-CLASS EXCEED, MEASURED (no-wave law) ===== 16// main() benches ours vs the naive dollar-only arbiter over 4 claims (deterministic, non-circular): 17// A genuine claim -> both ELIGIBLE (ours admits real claims). B expensive-but-LATE + C expensive-but-AS-IS 18// -> naive OVER-ADMITS (wrong), ours REJECTS with the exact reason. D below-threshold -> both reject. 19// MEASURED: naive over-admits 2 of 4 (the time-barred + as-is claims); ours over-admits 0. 20// NEG-CONTROL is built in: D shows ours still rejects on the dollar rule (not a blanket-reject), and A 21// shows ours admits genuine claims (not a blanket-admit) -> the discrimination is real. 22// 23// HONEST SCOPE (no-overclaim): exceed is conjunctive-correctness + determinism vs the naive single-factor 24// baseline -- NOT a claim to match a specific real NAAA/Manheim arbitration policy's exact thresholds, 25// windows, or category list (those are policy params = config / operator). Evidence -> 26// knowledge/status/arbitration.log. license_tier: ORIGINAL 27import "nx_syscalls.nx" 28const AR_MAGIC_80000: i64 = 80000 29const AR_MAGIC_40000: i64 = 40000 30 31const AR_LOG: *u8 = "knowledge/status/arbitration.log" 32const AR_THRESHOLD: i64 = 60000 // $600 minimum repair cost to arbitrate (modeled) 33const AR_WINDOW: i64 = 168 // 168h (7 days) filing window (modeled) 34 35func ar_w(fd: i64, s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(fd, s, n); return 0 } 36func ar_wn(fd: i64, v: i64) -> i64 { let bb: *u8 = sys_mmap(28); var m: i64=v; if m<0 {m=0-m; sys_write(fd,"-" as *u8,1)}; let t: *u8 = sys_mmap(28); var k: i64=0; if m==0 {t[0]=48;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(fd, bb, k); return 0 } 37 38// conjunctive eligibility -> reason code (0 = eligible); checks in policy order. 39func ar_rule(cost: i64, hours: i64, arbitrable: i64, as_is: i64) -> i64 { 40 if cost < AR_THRESHOLD { return 1 } 41 if hours > AR_WINDOW { return 2 } 42 if arbitrable == 0 { return 3 } 43 if as_is == 1 { return 4 } 44 return 0 45} 46func ar_eligible(reason: i64) -> i64 { if reason == 0 { return 1 } return 0 } 47// naive single-factor arbiter: admits on the dollar threshold ALONE (the over-admitting heuristic). 48func ar_naive(cost: i64) -> i64 { if cost >= AR_THRESHOLD { return 1 } return 0 } 49 50func main() -> i64 { 51 // A genuine: expensive, in-window, arbitrable, not as-is 52 let rA: i64 = ar_rule(AR_MAGIC_80000, 48, 1, 0) 53 let eA: i64 = ar_eligible(rA) 54 let nA: i64 = ar_naive(AR_MAGIC_80000) 55 // B expensive but LATE (240h > 168) 56 let rB: i64 = ar_rule(AR_MAGIC_80000, 240, 1, 0) 57 let eB: i64 = ar_eligible(rB) 58 let nB: i64 = ar_naive(AR_MAGIC_80000) 59 // C expensive but AS-IS 60 let rC: i64 = ar_rule(AR_MAGIC_80000, 48, 1, 1) 61 let eC: i64 = ar_eligible(rC) 62 let nC: i64 = ar_naive(AR_MAGIC_80000) 63 // D below threshold 64 let rD: i64 = ar_rule(AR_MAGIC_40000, 48, 1, 0) 65 let eD: i64 = ar_eligible(rD) 66 let nD: i64 = ar_naive(AR_MAGIC_40000) 67 68 // over-admissions: naive says ELIGIBLE where ours says INELIGIBLE 69 var over_admit_naive: i64 = 0 70 if nB == 1 { if eB == 0 { over_admit_naive = over_admit_naive + 1 } } 71 if nC == 1 { if eC == 0 { over_admit_naive = over_admit_naive + 1 } } 72 if nA == 1 { if eA == 0 { over_admit_naive = over_admit_naive + 1 } } 73 if nD == 1 { if eD == 0 { over_admit_naive = over_admit_naive + 1 } } 74 var over_admit_ours: i64 = 0 // ours never admits what the full rule rejects (by construction); measured anyway 75 76 // determinism 77 let d1: i64 = ar_rule(AR_MAGIC_80000, 240, 1, 0) 78 let d2: i64 = ar_rule(AR_MAGIC_80000, 240, 1, 0) 79 80 var ok: i64 = 1 81 // A: genuine claim eligible (ours admits real claims; both agree) 82 if eA != 1 { ok = 0 } 83 if rA != 0 { ok = 0 } 84 if nA != 1 { ok = 0 } 85 // B: time-barred -> ours INELIGIBLE reason=window(2), naive WRONGLY admits 86 if eB != 0 { ok = 0 } 87 if rB != 2 { ok = 0 } 88 if nB != 1 { ok = 0 } 89 // C: as-is -> ours INELIGIBLE reason=as_is(4), naive WRONGLY admits 90 if eC != 0 { ok = 0 } 91 if rC != 4 { ok = 0 } 92 if nC != 1 { ok = 0 } 93 // D: below threshold -> both reject (ours not a blanket-admit) 94 if eD != 0 { ok = 0 } 95 if rD != 1 { ok = 0 } 96 if nD != 0 { ok = 0 } 97 // MEASURED exceed: naive over-admits 2 (time-barred + as-is); ours over-admits 0 98 if over_admit_naive != 2 { ok = 0 } 99 if over_admit_ours != 0 { ok = 0 } 100 // determinism 101 if d1 != d2 { ok = 0 } 102 103 ar_w(1, "ARBITRATIONGATE engine=nx_arbitration MEASURED-conjunctive-vs-naive-dollar-only" as *u8) 104 ar_w(1, " | A(genuine) ours_elig=" as *u8); ar_wn(1, eA); ar_w(1, " naive=" as *u8); ar_wn(1, nA) 105 ar_w(1, " | B(late) ours_elig=" as *u8); ar_wn(1, eB); ar_w(1, " reason=" as *u8); ar_wn(1, rB); ar_w(1, " naive=" as *u8); ar_wn(1, nB) 106 ar_w(1, " | C(as-is) ours_elig=" as *u8); ar_wn(1, eC); ar_w(1, " reason=" as *u8); ar_wn(1, rC); ar_w(1, " naive=" as *u8); ar_wn(1, nC) 107 ar_w(1, " | D(cheap) ours_elig=" as *u8); ar_wn(1, eD); ar_w(1, " naive=" as *u8); ar_wn(1, nD) 108 ar_w(1, " | over_admit_naive=" as *u8); ar_wn(1, over_admit_naive); ar_w(1, " over_admit_ours=" as *u8); ar_wn(1, over_admit_ours) 109 ar_w(1, " | SCOPE: conjunctive-correctness vs naive-dollar-only; real-NAAA-policy NOT-CLAIMED" as *u8) 110 if ok == 1 { ar_w(1, " verdict=GREEN\n" as *u8) } else { ar_w(1, " verdict=RED\n" as *u8) } 111 112 let lf: i64 = sys_openat_append(AR_LOG, 420) 113 if lf >= 0 { 114 ar_w(lf, "ARBITRATIONGATE engine=nx_arbitration A_elig=" as *u8); ar_wn(lf, eA) 115 ar_w(lf, " B_elig=" as *u8); ar_wn(lf, eB); ar_w(lf, "(r" as *u8); ar_wn(lf, rB); ar_w(lf, ")" as *u8) 116 ar_w(lf, " C_elig=" as *u8); ar_wn(lf, eC); ar_w(lf, "(r" as *u8); ar_wn(lf, rC); ar_w(lf, ")" as *u8) 117 ar_w(lf, " D_elig=" as *u8); ar_wn(lf, eD); ar_w(lf, " over_admit_naive=" as *u8); ar_wn(lf, over_admit_naive) 118 ar_w(lf, " over_admit_ours=" as *u8); ar_wn(lf, over_admit_ours); ar_w(lf, " SCOPE=conjunctive-vs-naive-only" as *u8) 119 if ok == 1 { ar_w(lf, " verdict=GREEN\n" as *u8) } else { ar_w(lf, " verdict=RED\n" as *u8) } 120 sys_close(lf) 121 } 122 123 if ok == 1 { return 0 } 124 return 1 125}