code wiki / (root) / nx_swcompare_compute.nx
`nx_swcompare_compute.nx` source

↩ module page · 225 lines · 20542 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"
11import "nx_swcompare_lib.nx"   // w/wc/wn/c_read + sc_theme_pass: ONE copy for the whole compare surface
12const K_MAGIC_262144: i64 = 262144
13
14// w / wc / wn / c_read WERE DEFINED HERE and are now COMPOSED from nx_swcompare_lib.nx, which already
15// carried byte-identical copies -- the lib's own header records them as AUTO-EXTRACTED, so this file was
16// the copy left behind rather than the original. FOUR compare generators each holding a private copy of
17// the same four helpers is the duplicate-ruler defect at fleet scale: nothing compares the copies, so
18// whichever drifts first drifts in silence and the pages diverge without a single failing test.
19// This is also what made the palette consolidation impossible until now -- sc_theme_pass could not be
20// called from a file that shared no lib with the generator that already used it.
21func c_exists(path: *u8) -> i64 { let fd: i64 = sys_openat_rd(path); if fd < 0 { return 0 } sys_close(fd); return 1 }
22func c_has(buf: *u8, n: i64, needle: *u8) -> i64 {
  var i: i64 = 0
  while i < n { var k: i64 = 0; var hit: i64 = 1
      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 }
      if hit == 1 { if k > 0 { return 1 } } i = i + 1 }
  return 0
28}
29func c_file_has(path: *u8, needle: *u8, buf: *u8, cap: i64) -> i64 {
  let n: i64 = c_read(path, buf, cap); if n <= 0 { return 0 }
  return c_has(buf, n, needle)
32}
33// streq was the FIFTH duplicate in this file and is now composed from nx_swcompare_lib.nx (byte-identical
34// body). c_exists / c_has / c_file_has stay local because the lib genuinely does not carry them -- the test
35// for "is this a duplicate" is whether the shared layer already owns it, never whether it looks generic.
36
37func isp(ns: i64) -> i64 { if ns == 1 { return 1 } return 0 }
38func ise(ns: i64) -> i64 { if ns == 2 { return 1 } return 0 }
39func isa(ns: i64) -> i64 { if ns == 0 { return 1 } return 0 }
40
41func con_row(label: *u8, ns: i64) -> i64 {
  w(1, "  [" as *u8)
  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) } } }
  w(1, "] " as *u8); w(1, label); w(1, "\n" as *u8); return 0
45}
46
47func td_badge(fd: i64, code: i64) -> i64 {
  if code == 1 { w(fd, "<td class='b y'>Yes</td>" as *u8); return 0 }
  if code == 3 { w(fd, "<td class='b p'>Part</td>" as *u8); return 0 }
  if code == 2 { w(fd, "<td class='b ex'>Best</td>" as *u8); return 0 }
  w(fd, "<td class='b n'>No</td>" as *u8); return 0
52}
53func html_row(fd: i64, cat: *u8, ns: i64, wo: i64, sy: i64, sg: i64, mx: i64, note: *u8) -> i64 {
  w(fd, "<tr><td class='cat'>" as *u8); w(fd, cat); w(fd, "</td>" as *u8)
  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) } } }
  td_badge(fd, wo); td_badge(fd, sy); td_badge(fd, sg); td_badge(fd, mx)
  w(fd, "<td class='note'>" as *u8); w(fd, note); w(fd, "</td></tr>\n" as *u8)
  return 0
59}
60
61func main(argc: i64, argv: *i64) -> i64 {
  let cap: i64 = K_MAGIC_262144
  let buf: *u8 = sys_mmap(cap)
64
  let BIGINT: *u8 = "runtime/nx_bigint.nx"
  let RAT:    *u8 = "runtime/_hdl_build/nx_rational.nx"
  let CX:     *u8 = "runtime/nx_complex.nx"
  let DERIV:  *u8 = "runtime/nx_derive.nx"
  let INTG:   *u8 = "runtime/nx_integral.nx"
  let SINT:   *u8 = "runtime/nx_calc_integrate.nx"
  let SERIES: *u8 = "runtime/nx_calc_series.nx"
  let SOLVE:  *u8 = "runtime/nx_calc_solve.nx"
  let LINALG: *u8 = "runtime/nx_linalg.nx"
  let MATRIX: *u8 = "runtime/nx_matrix.nx"
  let POLY:   *u8 = "runtime/nx_poly.nx"
  let GEOM:   *u8 = "runtime/nx_geom.nx"
  let GRAPH:  *u8 = "runtime/nx_graphalg.nx"
  let PROB:   *u8 = "runtime/nx_probability.nx"
  let TENSOR: *u8 = "runtime/nx_autograd_tensor.nx"
  let UNITS:  *u8 = "runtime/nx_units.nx"
  let SAT:    *u8 = "runtime/nx_sat_solver.nx"
  let NT:     *u8 = "runtime/nx_triangulation_number_theory.nx"
  let ATP:    *u8 = "runtime/nx_atp_to_derive.nx"
  let ARITH:  *u8 = "runtime/nx_arith.nx"
  let BAR:    *u8 = "knowledge/compare/compute-bar.txt"
86
  let ns_bigint: i64 = c_file_has(BIGINT, "bi_add" as *u8, buf, cap)
  let ns_rat:    i64 = c_file_has(RAT, "rat_norm" as *u8, buf, cap)
  let ns_cx:     i64 = c_file_has(CX, "nx_cx_add" as *u8, buf, cap)
  let ns_deriv:  i64 = c_file_has(DERIV, "nx_deriv_chain_alloc" as *u8, buf, cap)
  let ns_intg:   i64 = c_file_has(INTG, "nx_integral_rect_sum" as *u8, buf, cap)
  let ns_sint:   i64 = c_file_has(SINT, "nx_calc_integrate" as *u8, buf, cap)
  let ns_series: i64 = c_file_has(SERIES, "nx_calc_maclaurin" as *u8, buf, cap)
  let ns_solve:  i64 = c_file_has(SOLVE, "nx_calc_solve_quadratic" as *u8, buf, cap)
  let ns_linalg: i64 = c_file_has(LINALG, "nx_vec_add" as *u8, buf, cap)
  let ns_matrix: i64 = c_file_has(MATRIX, "nx_matrix_alloc" as *u8, buf, cap)
  let ns_poly:   i64 = c_file_has(POLY, "nx_poly_mul" as *u8, buf, cap)
  let ns_geom:   i64 = c_file_has(GEOM, "nx_geom_hough_line" as *u8, buf, cap)
  let ns_graph:  i64 = c_file_has(GRAPH, "nx_graphalg_add_edge" as *u8, buf, cap)
  let ns_prob:   i64 = c_file_has(PROB, "nx_prob_pr" as *u8, buf, cap)
  let ns_tensor: i64 = c_file_has(TENSOR, "ta_leaf" as *u8, buf, cap)
  let ns_units:  i64 = c_file_has(UNITS, "nx_dim_meter" as *u8, buf, cap)
  let ns_sat:    i64 = c_file_has(SAT, "nx_sat_add_clause" as *u8, buf, cap)
  let ns_nt:     i64 = c_file_has(NT, "nx_check_prop" as *u8, buf, cap)
  let ns_atp:    i64 = c_file_has(ATP, "nx_atp_to_derive" as *u8, buf, cap)
  let ns_af:     i64 = c_file_has("runtime/nx_autoformalize.nx" as *u8, "af_derive_sum" as *u8, buf, cap)
  let ns_arith:  i64 = c_file_has(ARITH, "nx_arith_mult" as *u8, buf, cap)
  let sov_ok: i64 = c_exists(BIGINT) & c_exists(ARITH) & (1 - c_file_has(BIGINT, "dlopen" as *u8, buf, cap))
  let det_ok: i64 = c_exists(RAT) & c_file_has(RAT, "rat_gcd" as *u8, buf, cap)
  let ns_sov: i64 = sov_ok * 2
  let ns_det: i64 = det_ok * 2
112
  let corpus: i64 = c_exists(BAR)
  let neg: i64 = c_file_has(BIGINT, "wolfram_risch_definite_integral" as *u8, buf, cap)
115
  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)
  var exceeds: i64 = ise(ns_sov)+ise(ns_det)
  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)
  let total: i64 = present + exceeds + absent
  var coverage: i64 = 0
  if total > 0 { coverage = ((exceeds + present) * 1000) / total }
122
  var html: i64 = 0
  if argc >= 2 { if streq(argv[1] as *u8, "html" as *u8) == 1 { html = 1 } }
125
  if html == 1 {
      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)
      w(1, "<title>Nishi vs the Field -- Computational Mathematics</title>\n<style>\n" as *u8)
      // PALETTE CONSOLIDATED 2026-08-27. This line was BYTE-IDENTICAL to nx_swcompare_office.nx:134 --
      // one design written twice, in two files, with nothing comparing them. It is now the LIGHT half of
      // the brand SSOT (nx_brand_tokens via sc_theme_pass), the same source nx_swcompare_matrix has
      // always composed, so there is one palette for the compare surface instead of three.
      // ZERO VISUAL CHANGE BY CONSTRUCTION IN THIS THEME: these exact rgb values became the SSOT's light
      // rows for ok/part/absent/exceed, and the chrome tokens resolve through the same aliases this CSS
      // already reads. The page also gains the dark theme it never had.
      sc_theme_pass(1)
      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)
      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)
      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)
      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)
      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)
      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)
      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)
      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)
      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)
      // THE PRINT SHEET GOES LAST (datavis DV7, 2026-09-15): order is its specificity -- see sc_print_css in nx_swcompare_lib
      sc_print_css(1)
      w(1, "</style></head><body>\n" as *u8)
      w(1, "<p class='crumb'><a href='/'>Nishi Family</a> &rsaquo; <a href='/compare'>Compare</a> &rsaquo; Computational Mathematics &nbsp;&middot;&nbsp; <a href='/compare/computational/frontier'>Frontier Radar</a> &nbsp;&middot;&nbsp; <a href='/compare/computational/bench'>Run-and-Compare Bench</a></p>\n" as *u8)
      w(1, "<h1>Nishi vs the Field</h1>\n<p class='sub'>Computational Mathematics &mdash; mechanically measured, liar-killed, sovereign.</p>\n" as *u8)
      w(1, "<p class='sub' style='font-size:.9rem'>Nishi &nbsp;vs&nbsp; Wolfram Language &middot; SymPy &middot; SageMath &middot; Maxima</p>\n" as *u8)
      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)
      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)
      html_row(1, "Arbitrary-precision integers" as *u8, ns_bigint, 1,1,1,1, "nx_bigint (bi_add) -- unbounded integers" as *u8)
      html_row(1, "Exact rationals" as *u8, ns_rat, 1,1,1,1, "nx_rational (rat_norm/rat_gcd)" as *u8)
      html_row(1, "Complex numbers" as *u8, ns_cx, 1,1,1,1, "nx_complex (nx_cx_add)" as *u8)
      html_row(1, "Symbolic differentiation" as *u8, ns_deriv, 1,1,1,1, "nx_derive (chain rule); Wolfram deepest" as *u8)
      html_row(1, "Numeric integration" as *u8, ns_intg, 1,1,1,1, "nx_integral (Riemann sum)" as *u8)
      html_row(1, "Symbolic integration" as *u8, ns_sint, 1,1,1,1, "nx_calc_integrate; Wolfram Risch+ far deeper" as *u8)
      html_row(1, "Series expansion" as *u8, ns_series, 1,1,1,1, "nx_calc_series (Maclaurin)" as *u8)
      html_row(1, "Equation solving" as *u8, ns_solve, 1,1,1,1, "nx_calc_solve (linear/quadratic); peers solve general" as *u8)
      html_row(1, "Linear algebra (vectors)" as *u8, ns_linalg, 1,1,1,1, "nx_linalg (nx_vec_add)" as *u8)
      html_row(1, "Matrices" as *u8, ns_matrix, 1,1,1,1, "nx_matrix (alloc/ops)" as *u8)
      html_row(1, "Polynomials" as *u8, ns_poly, 1,1,1,1, "nx_poly (mul/add/derivative/eval)" as *u8)
      html_row(1, "Computational geometry" as *u8, ns_geom, 1,3,1,3, "nx_geom (Hough, orientation); SymPy/Maxima partial" as *u8)
      html_row(1, "Graph algorithms" as *u8, ns_graph, 1,3,1,0, "nx_graphalg; Sage=NetworkX rich; Maxima none" as *u8)
      html_row(1, "Probability" as *u8, ns_prob, 1,1,1,3, "nx_probability (measure over omega)" as *u8)
      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)
      html_row(1, "Units / dimensional analysis" as *u8, ns_units, 1,1,1,3, "nx_units (SI dimensions)" as *u8)
      html_row(1, "SAT / constraint solving" as *u8, ns_sat, 1,3,1,0, "nx_sat_solver (clauses); Maxima none" as *u8)
      html_row(1, "Number theory (primality)" as *u8, ns_nt, 1,1,1,1, "nx_triangulation_number_theory; prime proofs" as *u8)
      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)
      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)
      html_row(1, "Peano / foundational arithmetic" as *u8, ns_arith, 1,1,1,1, "nx_arith (successor/plus/mult from axioms)" as *u8)
      w(1, "<tr><td colspan='7' style='background:var(--soft);font-weight:600;font-size:.85rem'>Distinguishing axes &mdash; where a sovereign integer stack genuinely leads</td></tr>\n" as *u8)
      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)
      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)
      w(1, "</tbody></table></div>\n" as *u8)
      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)
      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)
      w(1, "<div class='verdict'><b>Honest verdict.</b> Nishi has <b>broad computational presence</b> &mdash; 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)
      w(1, "<p class='foot'>Generated by nx_swcompare_compute (sovereign NishiLang organ) &mdash; 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)
      w(1, "</body></html>\n" as *u8)
      sys_exit(0); return 0
  }
186
  w(1, "=== NX-SWCOMPARE-COMPUTE -- Nishi computational-math stack MEASURED vs Wolfram / SymPy / SageMath / Maxima ===\n" as *u8)
  w(1, "  -- SOTA bar grounded in corpus="); wn(1, corpus); w(1, " (knowledge/compare/compute-bar.txt)\n" as *u8)
  con_row("Arbitrary-precision integers (nx_bigint)" as *u8, ns_bigint)
  con_row("Exact rationals (nx_rational)" as *u8, ns_rat)
  con_row("Complex numbers (nx_complex)" as *u8, ns_cx)
  con_row("Symbolic differentiation (nx_derive)" as *u8, ns_deriv)
  con_row("Numeric integration (nx_integral)" as *u8, ns_intg)
  con_row("Symbolic integration (nx_calc_integrate)" as *u8, ns_sint)
  con_row("Series expansion (nx_calc_series)" as *u8, ns_series)
  con_row("Equation solving (nx_calc_solve)" as *u8, ns_solve)
  con_row("Linear algebra (nx_linalg)" as *u8, ns_linalg)
  con_row("Matrices (nx_matrix)" as *u8, ns_matrix)
  con_row("Polynomials (nx_poly)" as *u8, ns_poly)
  con_row("Computational geometry (nx_geom)" as *u8, ns_geom)
  con_row("Graph algorithms (nx_graphalg)" as *u8, ns_graph)
  con_row("Probability (nx_probability)" as *u8, ns_prob)
  con_row("Tensors + autodiff (nx_autograd_tensor)" as *u8, ns_tensor)
  con_row("Units / dimensional analysis (nx_units)" as *u8, ns_units)
  con_row("SAT / constraint solving (nx_sat_solver)" as *u8, ns_sat)
  con_row("Number theory (nx_triangulation_number_theory)" as *u8, ns_nt)
  con_row("Automated theorem proving (nx_atp_to_derive)" as *u8, ns_atp)
  con_row("Autoformalization rung 1 (nx_autoformalize)" as *u8, ns_af)
  con_row("Peano / foundational arithmetic (nx_arith)" as *u8, ns_arith)
  con_row("EXCEEDS: sovereign bits-up computation" as *u8, ns_sov)
  con_row("EXCEEDS: no-float integer determinism" as *u8, ns_det)
  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")
213
  let liar_neg:    i64 = (neg == 0) as i64
  let liar_corpus: i64 = (corpus == 1) as i64
  let liar_core:   i64 = ns_bigint & ns_matrix & ns_deriv & ns_solve & ns_poly
  let liar_exbound: i64 = (exceeds == 2) as i64
  let liar_present: i64 = (present >= 15) as i64
  w(1, "  LIAR-KILL: neg-control-absent="); wn(1, liar_neg); w(1, "  corpus-grounded="); wn(1, liar_corpus)
  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")
  let ok: i64 = liar_neg & liar_corpus & liar_core & liar_exbound & liar_present
  w(1, "NX-SWCOMPARE-COMPUTE coverage="); wn(1, coverage); w(1, "/1000 EXCEEDS="); wn(1, exceeds); w(1, " verdict=")
  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 }
  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
225}
nx_swcompare_compute.nx source

`nx_swcompare_compute.nx` source
