nx_swcompare_compute.nx source
↩ module page · 220 lines · 19821 B
1// nx_swcompare_compute.nx -- MEASURED, LIAR-KILLED SoftwareCompare of the NISHI computational-math stack vs the state
2// of the art (Wolfram Language / Mathematica, SymPy, SageMath, Maxima). Each NISHI cell is PROVEN by reading the
3// REAL organ source on disk: the implementing symbol must EXIST. Competitor cells = documented capability presence,
4// grounded in knowledge/compare/compute-bar.txt (cited). Coverage is a CAPABILITY-PRESENCE fraction, NOT a
5// depth-parity score -- Wolfram LEADS depth in nearly every category; our EXCEEDS are ONLY the two sovereignty/
6// determinism axes. Two modes: default (no arg) = console census + liar-kill (the gate, exits 0/1); argv[1]="html"
7// = emit the SoftwareCompare page to stdout (the published nishifamily.com/compare artifact -- a sovereign
8// generator, not a hand-authored page). NOTE: no '#' or '!' in string literals (nx_cc lexer trap) -> rgb() colors
9// + the DOCTYPE '!' is emitted as a byte. license_tier: ORIGINAL expect_exit: 0
10import "nx_syscalls.nx"
11const K_MAGIC_262144: i64 = 262144
12
13func 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 }
14func wc(fd: i64, code: i64) -> i64 { let t: *u8 = sys_mmap(2); t[0] = code as u8; sys_write(fd, t, 1); return 0 }
15func wn(fd: i64, v: i64) -> i64 {
16 var m: i64 = v; if m < 0 { w(fd, "-" as *u8); m = 0 - m }
17 let t: *u8 = sys_mmap(24); var k: i64 = 0; if m == 0 { t[0] = 48 as u8; k = 1 }
18 while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
19 let o: *u8 = sys_mmap(24); var i: i64 = 0; while i < k { o[i] = t[k-1-i]; i = i + 1 } sys_write(fd, o, k); return 0
20}
21func c_read(path: *u8, buf: *u8, cap: i64) -> i64 {
22 let fd: i64 = sys_openat_rd(path); if fd < 0 { return 0 - 1 }
23 var tot: i64 = 0
24 while tot < cap { let r: i64 = sys_read(fd, (buf as i64 + tot) as *u8, cap - tot); if r <= 0 { break } tot = tot + r }
25 sys_close(fd); return tot
26}
27func c_exists(path: *u8) -> i64 { let fd: i64 = sys_openat_rd(path); if fd < 0 { return 0 } sys_close(fd); return 1 }
28func c_has(buf: *u8, n: i64, needle: *u8) -> i64 {
29 var i: i64 = 0
30 while i < n { var k: i64 = 0; var hit: i64 = 1
31 while needle[k] != (0 as u8) { if i + k >= n { hit = 0; k = 0 - 1; break } if buf[i+k] != needle[k] { hit = 0; break } k = k + 1 }
32 if hit == 1 { if k > 0 { return 1 } } i = i + 1 }
33 return 0
34}
35func c_file_has(path: *u8, needle: *u8, buf: *u8, cap: i64) -> i64 {
36 let n: i64 = c_read(path, buf, cap); if n <= 0 { return 0 }
37 return c_has(buf, n, needle)
38}
39func streq(a: *u8, b: *u8) -> i64 { var i: i64 = 0; while a[i] != (0 as u8) { if a[i] != b[i] { return 0 } i = i + 1 } if b[i] != (0 as u8) { return 0 } return 1 }
40
41func isp(ns: i64) -> i64 { if ns == 1 { return 1 } return 0 }
42func ise(ns: i64) -> i64 { if ns == 2 { return 1 } return 0 }
43func isa(ns: i64) -> i64 { if ns == 0 { return 1 } return 0 }
44
45func con_row(label: *u8, ns: i64) -> i64 {
46 w(1, " [" as *u8)
47 if ns == 2 { w(1, "EXCEEDS" as *u8) } else { if ns == 1 { w(1, "PRESENT" as *u8) } else { if ns == 3 { w(1, "PARTIAL" as *u8) } else { w(1, "ABSENT " as *u8) } } }
48 w(1, "] " as *u8); w(1, label); w(1, "\n" as *u8); return 0
49}
50
51func td_badge(fd: i64, code: i64) -> i64 {
52 if code == 1 { w(fd, "<td class='b y'>Yes</td>" as *u8); return 0 }
53 if code == 3 { w(fd, "<td class='b p'>Part</td>" as *u8); return 0 }
54 if code == 2 { w(fd, "<td class='b ex'>Best</td>" as *u8); return 0 }
55 w(fd, "<td class='b n'>No</td>" as *u8); return 0
56}
57func html_row(fd: i64, cat: *u8, ns: i64, wo: i64, sy: i64, sg: i64, mx: i64, note: *u8) -> i64 {
58 w(fd, "<tr><td class='cat'>" as *u8); w(fd, cat); w(fd, "</td>" as *u8)
59 if ns == 2 { w(fd, "<td class='b nc ex'>Best</td>" as *u8) } else { if ns == 1 { w(fd, "<td class='b nc y'>Yes</td>" as *u8) } else { if ns == 3 { w(fd, "<td class='b nc p'>Part</td>" as *u8) } else { w(fd, "<td class='b nc n'>No</td>" as *u8) } } }
60 td_badge(fd, wo); td_badge(fd, sy); td_badge(fd, sg); td_badge(fd, mx)
61 w(fd, "<td class='note'>" as *u8); w(fd, note); w(fd, "</td></tr>\n" as *u8)
62 return 0
63}
64
65func main(argc: i64, argv: *i64) -> i64 {
66 let cap: i64 = K_MAGIC_262144
67 let buf: *u8 = sys_mmap(cap)
68
69 let BIGINT: *u8 = "runtime/nx_bigint.nx"
70 let RAT: *u8 = "runtime/_hdl_build/nx_rational.nx"
71 let CX: *u8 = "runtime/nx_complex.nx"
72 let DERIV: *u8 = "runtime/nx_derive.nx"
73 let INTG: *u8 = "runtime/nx_integral.nx"
74 let SINT: *u8 = "runtime/nx_calc_integrate.nx"
75 let SERIES: *u8 = "runtime/nx_calc_series.nx"
76 let SOLVE: *u8 = "runtime/nx_calc_solve.nx"
77 let LINALG: *u8 = "runtime/nx_linalg.nx"
78 let MATRIX: *u8 = "runtime/nx_matrix.nx"
79 let POLY: *u8 = "runtime/nx_poly.nx"
80 let GEOM: *u8 = "runtime/nx_geom.nx"
81 let GRAPH: *u8 = "runtime/nx_graphalg.nx"
82 let PROB: *u8 = "runtime/nx_probability.nx"
83 let TENSOR: *u8 = "runtime/nx_autograd_tensor.nx"
84 let UNITS: *u8 = "runtime/nx_units.nx"
85 let SAT: *u8 = "runtime/nx_sat_solver.nx"
86 let NT: *u8 = "runtime/nx_triangulation_number_theory.nx"
87 let ATP: *u8 = "runtime/nx_atp_to_derive.nx"
88 let ARITH: *u8 = "runtime/nx_arith.nx"
89 let BAR: *u8 = "knowledge/compare/compute-bar.txt"
90
91 let ns_bigint: i64 = c_file_has(BIGINT, "bi_add" as *u8, buf, cap)
92 let ns_rat: i64 = c_file_has(RAT, "rat_norm" as *u8, buf, cap)
93 let ns_cx: i64 = c_file_has(CX, "nx_cx_add" as *u8, buf, cap)
94 let ns_deriv: i64 = c_file_has(DERIV, "nx_deriv_chain_alloc" as *u8, buf, cap)
95 let ns_intg: i64 = c_file_has(INTG, "nx_integral_rect_sum" as *u8, buf, cap)
96 let ns_sint: i64 = c_file_has(SINT, "nx_calc_integrate" as *u8, buf, cap)
97 let ns_series: i64 = c_file_has(SERIES, "nx_calc_maclaurin" as *u8, buf, cap)
98 let ns_solve: i64 = c_file_has(SOLVE, "nx_calc_solve_quadratic" as *u8, buf, cap)
99 let ns_linalg: i64 = c_file_has(LINALG, "nx_vec_add" as *u8, buf, cap)
100 let ns_matrix: i64 = c_file_has(MATRIX, "nx_matrix_alloc" as *u8, buf, cap)
101 let ns_poly: i64 = c_file_has(POLY, "nx_poly_mul" as *u8, buf, cap)
102 let ns_geom: i64 = c_file_has(GEOM, "nx_geom_hough_line" as *u8, buf, cap)
103 let ns_graph: i64 = c_file_has(GRAPH, "nx_graphalg_add_edge" as *u8, buf, cap)
104 let ns_prob: i64 = c_file_has(PROB, "nx_prob_pr" as *u8, buf, cap)
105 let ns_tensor: i64 = c_file_has(TENSOR, "ta_leaf" as *u8, buf, cap)
106 let ns_units: i64 = c_file_has(UNITS, "nx_dim_meter" as *u8, buf, cap)
107 let ns_sat: i64 = c_file_has(SAT, "nx_sat_add_clause" as *u8, buf, cap)
108 let ns_nt: i64 = c_file_has(NT, "nx_check_prop" as *u8, buf, cap)
109 let ns_atp: i64 = c_file_has(ATP, "nx_atp_to_derive" as *u8, buf, cap)
110 let ns_af: i64 = c_file_has("runtime/nx_autoformalize.nx" as *u8, "af_derive_sum" as *u8, buf, cap)
111 let ns_arith: i64 = c_file_has(ARITH, "nx_arith_mult" as *u8, buf, cap)
112 let sov_ok: i64 = c_exists(BIGINT) & c_exists(ARITH) & (1 - c_file_has(BIGINT, "dlopen" as *u8, buf, cap))
113 let det_ok: i64 = c_exists(RAT) & c_file_has(RAT, "rat_gcd" as *u8, buf, cap)
114 let ns_sov: i64 = sov_ok * 2
115 let ns_det: i64 = det_ok * 2
116
117 let corpus: i64 = c_exists(BAR)
118 let neg: i64 = c_file_has(BIGINT, "wolfram_risch_definite_integral" as *u8, buf, cap)
119
120 var present: i64 = isp(ns_bigint)+isp(ns_rat)+isp(ns_cx)+isp(ns_deriv)+isp(ns_intg)+isp(ns_sint)+isp(ns_series)+isp(ns_solve)+isp(ns_linalg)+isp(ns_matrix)+isp(ns_poly)+isp(ns_geom)+isp(ns_graph)+isp(ns_prob)+isp(ns_tensor)+isp(ns_units)+isp(ns_sat)+isp(ns_nt)+isp(ns_atp)+isp(ns_arith)+isp(ns_af)
121 var exceeds: i64 = ise(ns_sov)+ise(ns_det)
122 var absent: i64 = isa(ns_bigint)+isa(ns_rat)+isa(ns_cx)+isa(ns_deriv)+isa(ns_intg)+isa(ns_sint)+isa(ns_series)+isa(ns_solve)+isa(ns_linalg)+isa(ns_matrix)+isa(ns_poly)+isa(ns_geom)+isa(ns_graph)+isa(ns_prob)+isa(ns_tensor)+isa(ns_units)+isa(ns_sat)+isa(ns_nt)+isa(ns_atp)+isa(ns_arith)+isa(ns_af)
123 let total: i64 = present + exceeds + absent
124 var coverage: i64 = 0
125 if total > 0 { coverage = ((exceeds + present) * 1000) / total }
126
127 var html: i64 = 0
128 if argc >= 2 { if streq(argv[1] as *u8, "html" as *u8) == 1 { html = 1 } }
129
130 if html == 1 {
131 w(1, "<" as *u8); wc(1, 33); w(1, "DOCTYPE html>\n<html lang='en'><head><meta charset='utf-8'><meta name='viewport' content='width=device-width, initial-scale=1'>\n" as *u8)
132 w(1, "<title>Nishi vs the Field -- Computational Mathematics</title>\n<style>\n" as *u8)
133 w(1, ":root{--bg:rgb(255,255,255);--fg:rgb(22,22,34);--ac:rgb(42,77,143);--y:rgb(26,127,55);--p:rgb(178,106,0);--n:rgb(179,38,30);--ex:rgb(130,80,223);--line:rgb(227,227,234);--soft:rgb(246,247,251)}\n" as *u8)
134 w(1, "*{box-sizing:border-box}body{background:var(--bg);font-family:-apple-system,Segoe UI,Roboto,sans-serif;max-width:1080px;margin:5vh auto;padding:0 20px;color:var(--fg);line-height:1.6}\n" as *u8)
135 w(1, "h1{font-size:2rem;margin:0 0 4px}.sub{color:rgb(102,102,102);font-size:1.05rem;margin:0 0 4px}.crumb{font-size:.85rem;margin-bottom:18px}a{color:var(--ac)}\n" as *u8)
136 w(1, ".meth{background:var(--soft);border:1px solid var(--line);border-radius:12px;padding:14px 18px;margin:20px 0;font-size:.9rem;color:rgb(51,51,51)}\n" as *u8)
137 w(1, ".wrap{overflow-x:auto;border:1px solid var(--line);border-radius:12px}table{border-collapse:collapse;width:100%;min-width:860px;font-size:.93rem}\n" as *u8)
138 w(1, "th,td{padding:9px 12px;text-align:left;border-bottom:1px solid var(--line)}thead th{background:var(--soft);font-weight:600}\n" as *u8)
139 w(1, "td.b{text-align:center;font-weight:600}td.b.y{color:var(--y)}td.b.p{color:var(--p)}td.b.n{color:var(--n)}td.b.ex{color:var(--ex)}td.nc{background:rgb(238,243,255)}.cat{font-weight:600}.note{color:rgb(119,119,119);font-size:.83rem}\n" as *u8)
140 w(1, "th.nishi{color:var(--ac)}.tally{margin:20px 0;font-size:1.02rem}.badge{display:inline-block;padding:2px 8px;border-radius:20px;background:var(--soft);margin-right:6px;font-size:.85rem}\n" as *u8)
141 w(1, ".verdict{background:var(--soft);border-left:4px solid var(--ac);padding:12px 18px;border-radius:0 10px 10px 0;margin:18px 0}.foot{margin-top:28px;color:rgb(136,136,136);font-size:.78rem;border-top:1px solid var(--line);padding-top:14px}\n" as *u8)
142 w(1, "@media(prefers-color-scheme:dark){:root{--bg:rgb(15,15,20);--fg:rgb(230,230,238);--line:rgb(38,38,47);--soft:rgb(23,23,31)}td.nc{background:rgb(20,26,43)}}\n" as *u8)
143 w(1, "</style></head><body>\n" as *u8)
144 w(1, "<p class='crumb'><a href='/'>Nishi Family</a> › <a href='/compare'>Compare</a> › Computational Mathematics · <a href='/compare/computational/frontier'>Frontier Radar</a> · <a href='/compare/computational/bench'>Run-and-Compare Bench</a></p>\n" as *u8)
145 w(1, "<h1>Nishi vs the Field</h1>\n<p class='sub'>Computational Mathematics — mechanically measured, liar-killed, sovereign.</p>\n" as *u8)
146 w(1, "<p class='sub' style='font-size:.9rem'>Nishi vs Wolfram Language · SymPy · SageMath · Maxima</p>\n" as *u8)
147 w(1, "<div class='meth'><b>How this is scored.</b> Every <b>Nishi</b> cell is <b>measured</b>: the census reads the real organ source on disk and requires the implementing symbol to exist (no self-grading). Competitor cells record <b>documented capability presence</b> from compute-bar.txt (Wolfram/SymPy/Sage/Maxima docs). <b>Best</b>=exceeds all peers on this axis, <b>Yes</b>=present, <b>Part</b>=partial, <b>No</b>=absent. This measures capability <b>presence, not depth</b>: <b>Wolfram leads depth</b> in nearly every row (10,000+ curated functions + data). Nishi's genuine exceeds are the two sovereignty/determinism axes at the bottom.</div>\n" as *u8)
148 w(1, "<div class='wrap'><table><thead><tr><th>Capability</th><th class='nishi'>Nishi</th><th>Wolfram</th><th>SymPy</th><th>SageMath</th><th>Maxima</th><th>Notes</th></tr></thead><tbody>\n" as *u8)
149 html_row(1, "Arbitrary-precision integers" as *u8, ns_bigint, 1,1,1,1, "nx_bigint (bi_add) -- unbounded integers" as *u8)
150 html_row(1, "Exact rationals" as *u8, ns_rat, 1,1,1,1, "nx_rational (rat_norm/rat_gcd)" as *u8)
151 html_row(1, "Complex numbers" as *u8, ns_cx, 1,1,1,1, "nx_complex (nx_cx_add)" as *u8)
152 html_row(1, "Symbolic differentiation" as *u8, ns_deriv, 1,1,1,1, "nx_derive (chain rule); Wolfram deepest" as *u8)
153 html_row(1, "Numeric integration" as *u8, ns_intg, 1,1,1,1, "nx_integral (Riemann sum)" as *u8)
154 html_row(1, "Symbolic integration" as *u8, ns_sint, 1,1,1,1, "nx_calc_integrate; Wolfram Risch+ far deeper" as *u8)
155 html_row(1, "Series expansion" as *u8, ns_series, 1,1,1,1, "nx_calc_series (Maclaurin)" as *u8)
156 html_row(1, "Equation solving" as *u8, ns_solve, 1,1,1,1, "nx_calc_solve (linear/quadratic); peers solve general" as *u8)
157 html_row(1, "Linear algebra (vectors)" as *u8, ns_linalg, 1,1,1,1, "nx_linalg (nx_vec_add)" as *u8)
158 html_row(1, "Matrices" as *u8, ns_matrix, 1,1,1,1, "nx_matrix (alloc/ops)" as *u8)
159 html_row(1, "Polynomials" as *u8, ns_poly, 1,1,1,1, "nx_poly (mul/add/derivative/eval)" as *u8)
160 html_row(1, "Computational geometry" as *u8, ns_geom, 1,3,1,3, "nx_geom (Hough, orientation); SymPy/Maxima partial" as *u8)
161 html_row(1, "Graph algorithms" as *u8, ns_graph, 1,3,1,0, "nx_graphalg; Sage=NetworkX rich; Maxima none" as *u8)
162 html_row(1, "Probability" as *u8, ns_prob, 1,1,1,3, "nx_probability (measure over omega)" as *u8)
163 html_row(1, "Tensors + autodiff" as *u8, ns_tensor, 3,3,3,0, "nx_autograd_tensor -- reverse-mode autograd; the CAS peers are not autodiff-first" as *u8)
164 html_row(1, "Units / dimensional analysis" as *u8, ns_units, 1,1,1,3, "nx_units (SI dimensions)" as *u8)
165 html_row(1, "SAT / constraint solving" as *u8, ns_sat, 1,3,1,0, "nx_sat_solver (clauses); Maxima none" as *u8)
166 html_row(1, "Number theory (primality)" as *u8, ns_nt, 1,1,1,1, "nx_triangulation_number_theory; prime proofs" as *u8)
167 html_row(1, "Automated theorem proving" as *u8, ns_atp, 3,0,3,0, "nx_atp_to_derive -- ATP to derivation; none is a general ATP" as *u8)
168 html_row(1, "Autoformalization (informal to formal)" as *u8, ns_af, 3,0,0,0, "nx_autoformalize rung 1: words to Peano terms, kernel-checked derivation. Wolfram-Alpha parses NL math (far broader grammar) but emits no checked proofs" as *u8)
169 html_row(1, "Peano / foundational arithmetic" as *u8, ns_arith, 1,1,1,1, "nx_arith (successor/plus/mult from axioms)" as *u8)
170 w(1, "<tr><td colspan='7' style='background:var(--soft);font-weight:600;font-size:.85rem'>Distinguishing axes — where a sovereign integer stack genuinely leads</td></tr>\n" as *u8)
171 html_row(1, "Sovereign, bits-up (own language+compiler+syscalls, zero third-party runtime)" as *u8, ns_sov, 0,0,0,3, "Nishi computes with NO Python/C/Lisp/cloud beneath; Wolfram proprietary+cloud, others large dep stacks" as *u8)
172 html_row(1, "No-float, integer-deterministic by construction (bit-identical)" as *u8, ns_det, 3,3,3,3, "Nishi results are exact-integer + reproducible; peers default to floating point" as *u8)
173 w(1, "</tbody></table></div>\n" as *u8)
174 w(1, "<div class='tally'><span class='badge'>coverage " as *u8); wn(1, coverage); w(1, "/1000</span><span class='badge'>EXCEEDS " as *u8); wn(1, exceeds)
175 w(1, "</span><span class='badge'>PRESENT " as *u8); wn(1, present); w(1, "</span><span class='badge'>ABSENT " as *u8); wn(1, absent); w(1, "</span></div>\n" as *u8)
176 w(1, "<div class='verdict'><b>Honest verdict.</b> Nishi has <b>broad computational presence</b> — a real organ in every core category above, built bits-up in one sovereign language. It is <b>not</b> a depth rival to Wolfram: Wolfram leads depth (curated functions + data) in nearly every row, and the general symbolic engines (SymPy/Sage/Maxima) go deeper on symbolic integration/solving. Nishi's genuine <b>exceeds</b> are exactly two: sovereign bits-up computation and no-float integer determinism. The roadmap is depth, not breadth: deepen symbolic integration/solving and add curated computable data.</div>\n" as *u8)
177 w(1, "<p class='foot'>Generated by nx_swcompare_compute (sovereign NishiLang organ) — every Nishi cell verified against real organ source on disk; competitor cells from compute-bar.txt. Zero JS, zero trackers. Served bits-up by the Nishi stack.</p>\n" as *u8)
178 w(1, "</body></html>\n" as *u8)
179 sys_exit(0); return 0
180 }
181
182 w(1, "=== NX-SWCOMPARE-COMPUTE -- Nishi computational-math stack MEASURED vs Wolfram / SymPy / SageMath / Maxima ===\n" as *u8)
183 w(1, " -- SOTA bar grounded in corpus="); wn(1, corpus); w(1, " (knowledge/compare/compute-bar.txt)\n" as *u8)
184 con_row("Arbitrary-precision integers (nx_bigint)" as *u8, ns_bigint)
185 con_row("Exact rationals (nx_rational)" as *u8, ns_rat)
186 con_row("Complex numbers (nx_complex)" as *u8, ns_cx)
187 con_row("Symbolic differentiation (nx_derive)" as *u8, ns_deriv)
188 con_row("Numeric integration (nx_integral)" as *u8, ns_intg)
189 con_row("Symbolic integration (nx_calc_integrate)" as *u8, ns_sint)
190 con_row("Series expansion (nx_calc_series)" as *u8, ns_series)
191 con_row("Equation solving (nx_calc_solve)" as *u8, ns_solve)
192 con_row("Linear algebra (nx_linalg)" as *u8, ns_linalg)
193 con_row("Matrices (nx_matrix)" as *u8, ns_matrix)
194 con_row("Polynomials (nx_poly)" as *u8, ns_poly)
195 con_row("Computational geometry (nx_geom)" as *u8, ns_geom)
196 con_row("Graph algorithms (nx_graphalg)" as *u8, ns_graph)
197 con_row("Probability (nx_probability)" as *u8, ns_prob)
198 con_row("Tensors + autodiff (nx_autograd_tensor)" as *u8, ns_tensor)
199 con_row("Units / dimensional analysis (nx_units)" as *u8, ns_units)
200 con_row("SAT / constraint solving (nx_sat_solver)" as *u8, ns_sat)
201 con_row("Number theory (nx_triangulation_number_theory)" as *u8, ns_nt)
202 con_row("Automated theorem proving (nx_atp_to_derive)" as *u8, ns_atp)
203 con_row("Autoformalization rung 1 (nx_autoformalize)" as *u8, ns_af)
204 con_row("Peano / foundational arithmetic (nx_arith)" as *u8, ns_arith)
205 con_row("EXCEEDS: sovereign bits-up computation" as *u8, ns_sov)
206 con_row("EXCEEDS: no-float integer determinism" as *u8, ns_det)
207 w(1, " TALLY: EXCEEDS="); wn(1, exceeds); w(1, " PRESENT="); wn(1, present); w(1, " ABSENT="); wn(1, absent); w(1, " (of "); wn(1, total); w(1, " axes) coverage="); wn(1, coverage); w(1, "/1000\n")
208
209 let liar_neg: i64 = (neg == 0) as i64
210 let liar_corpus: i64 = (corpus == 1) as i64
211 let liar_core: i64 = ns_bigint & ns_matrix & ns_deriv & ns_solve & ns_poly
212 let liar_exbound: i64 = (exceeds == 2) as i64
213 let liar_present: i64 = (present >= 15) as i64
214 w(1, " LIAR-KILL: neg-control-absent="); wn(1, liar_neg); w(1, " corpus-grounded="); wn(1, liar_corpus)
215 w(1, " core-present-proven="); wn(1, liar_core); w(1, " exceeds-bounded-to-2="); wn(1, liar_exbound); w(1, " present>=15="); wn(1, liar_present); w(1, "\n")
216 let ok: i64 = liar_neg & liar_corpus & liar_core & liar_exbound & liar_present
217 w(1, "NX-SWCOMPARE-COMPUTE coverage="); wn(1, coverage); w(1, "/1000 EXCEEDS="); wn(1, exceeds); w(1, " verdict=")
218 if ok == 1 { w(1, "MEASURED-HONEST (liar-killed) -- broad sovereign compute presence; depth trails Wolfram; 2 genuine exceeds (sovereignty + no-float determinism)\n" as *u8); sys_exit(0); return 0 }
219 w(1, "RED (a check failed: neg-control leaked, corpus missing, a core organ absent, or EXCEEDS claimed beyond the 2 honest axes)\n" as *u8); sys_exit(1); return 1
220}