Nishi Family › Compare › Computational Mathematics
Nishi Compare · measured, not asserted
Computational Mathematics
Nishi vs the field — every Nishi cell is measured against real organ source at emit time; each gap names the watch contract that will close it.
Nishi sovereign integer computational-mathematics stack vs Wolfram Language and SymPy and SageMath and Maxima -- capability PRESENCE measured against real organ source, not depth
Layer 1 · Executive
Where we are. Broad and shallow, and honest about which. computational.matrix measures 23 axes and finds a real organ behind every one of them -- arbitrary-precision integers, exact rationals, complex numbers, symbolic differentiation, numeric and symbolic integration, series, equation solving, vectors, matrices, polynomials, computational geometry, graph algorithms, probability, tensors with reverse-mode autodiff, units and dimensional analysis, SAT, number theory, automated theorem proving, autoformalization and Peano arithmetic -- all built bits-up in one sovereign language with no Python, C, Lisp or cloud runtime underneath. That breadth is genuine and unusual. The DEPTH is not there yet and the board says so on the rows themselves: symbolic integration exists but "Wolfram Risch-plus is far deeper", equation solving covers linear and quadratic while "Wolfram and Sage solve general systems", series expansion ships Maclaurin only while "peers ship general Taylor and Laurent", and numeric integration is a Riemann rectangle sum while "peers ship adaptive quadrature". Exactly two axes are marked as ours to lead, and both are structural rather than depth claims: sovereign bits-up computation, and no-float integer determinism that makes every result reproducible bit-for-bit where every peer defaults to floating point.
Where we need to go. Convert breadth into depth on the four axes the board already names, then add the one category the estate has none of. The order is deliberately cheapest-and-most-concrete first, because the two headline items are also the two hardest and starting there would stall the lane. Throughout, the two declared exceeds are shipping criteria no rung may trade away: nothing may introduce a third-party runtime, and nothing may introduce a float. That second constraint is not a handicap here, it is the differentiator -- a Groebner basis over exact rationals and a quadrature error bound computed in integers are reproducible in a way no floating-point CAS can offer.
The unit. 1 u = one measured session-leg (organ plus gate plus a re-measured row), the pmdash and charsim calibration used across the estate. THESE ESTIMATES ARE A BOUND, NOT A MEASUREMENT, and the reason is stated rather than hidden: no rung has landed in THIS domain yet, so there is no native calibration point and the figures are carried over from sibling lanes. They will be republished as actual-against-estimate the moment the first rung lands, the way comms recalibrated on C1.
Cost to close the two concrete depth gaps: 2.5 u. CM4 adaptive quadrature plus CM3 general Taylor and Laurent. These are the cheapest rungs and the two whose deficits are stated most precisely on the board, so they are the ones a referee can check fastest.
Cost to the stated roadmap headline: 6 u more. CM1 Risch-class symbolic integration plus CM2 general system solving -- the two items this domain's own verdict names as the roadmap. Both are algorithm work rather than plumbing, which is why they are estimated at 3 u each and sequenced after the cheap pair.
Cost to the one category we have none of: 2 u more. CM5 curated computable data, the third item in the verdict and the only axis on this board with no presence row at all. Program total 10.5 u and the three figures sum.
Research bar. Wolfram Language 14 is measured on the depth bar in nearly every row on this board, plus computable curated data. Theirs: 10,000+ curated functions and a curated data layer no open system matches. Ours: CM1 CM2 and CM5 each name a capability Wolfram already has, and CM5 is the axis where it is the only column that ships anything.
Research bar. SymPy 1.13 is measured on the open-source symbolic reference, and the one whose algorithms are readable rather than proprietary. Theirs: ships a Risch implementation and general series expansion in pure Python. Ours: CM1 and CM3 measure against it as the reachable open bar rather than against Wolfram.
Research bar. SageMath 10.x is measured on breadth by integration -- it wraps a large stack to reach general system solving and rich graph and geometry support. Theirs: solves general systems and wraps NetworkX for graphs. Ours: CM2 measures against it, and the contrast is the point: Sage reaches this by depending on a large third-party stack, which is precisely the move this estate does not make.
Research bar. Maxima 5.47 is measured on the long-lived Lisp CAS, the smallest honest comparison for a solo stack. Theirs: ships Risch integration and general series in a codebase one person can read. Ours: the closest analogue to what CM1 and CM3 should look like at completion for a sovereign stack.
21 of 28 capabilities measured|2 of them measured exceeds|7 open|coverage 750/1000|adoption 7 full / 14 partial
Layer 2 · Roadmap
Do this next — computed by the ranker, never chosen by a seat
Order from nx_compare_rank (nx_dr_ocm: (deficit + cost-of-delay + option + enables) x sponsor x self-sufficiency x momentum / cost). FINISH rows are rungs whose symbol is present but whose organ is short of full adoption: the cheapest closures on this board, listed before any new work. Stamp: # asof=1787883574 domain=computational target_version=0.1 rungs=5 done=0 open=5 finish=0 ranker=nx_dr_ocm
| # | Stage | Rung | Priority | Derivation |
|---|---|---|---|---|
| #1 | 0.1 | Adaptive quadrature with an error bound (CM4) ni_quad_adaptive | 400 | v=4 m=1 c=10 |
| #2 | 0.1 | General Taylor and Laurent series (CM3) cs_series_laurent | 333 | v=5 m=1 c=15 |
| #3 | later | Symbolic integration to Risch class (CM1) ci_risch_integrate | 133 | v=4 m=1 c=30 |
| #4 | later | Equation solving over general systems (CM2) cs_solve_system | 133 | v=4 m=1 c=30 |
| #5 | later | Curated computable data (CM5) cd_curated_query | 100 | v=2 m=1 c=20 |
Critical path — contract, done-rule, executor, cost
| Rung | Closes with | Definition of done (pre-declared) | Executor | Est. |
|---|---|---|---|---|
| Adaptive quadrature with an error bound (CM4) | ni_quad_adaptive | The board grades numeric integration present and its note names the gap as adaptive quadrature. Today nx_integral ships a Riemann rectangle sum whose error is neither estimated nor reported. Subdivide on a measured local error estimate and carry the bound through. ACCEPT: on a pre-declared set of integrals with known exact values the returned interval CONTAINS the true value at every requested tolerance, with a NEG-CONTROL that a function which cannot meet the tolerance on the given interval REFUSES and names the subinterval where the estimate failed rather than returning a number. A quadrature that always returns an answer has not been shown to know when it is wrong. | Organ | 1 u |
| General Taylor and Laurent series (CM3) | cs_series_laurent | The board grades series expansion present and its note names the gap as general Taylor and Laurent. Today nx_calc_series expands about zero only. Expand about an arbitrary point and admit negative powers. ACCEPT: an expansion about a non-zero point agrees term-for-term with the same function re-centred by an independent path, and a function with a pole yields its principal part with the residue matching a separately computed contour value -- plus a NEG-CONTROL that a point where the function is not meromorphic REFUSES instead of returning a truncated series that looks valid. | Organ | 1.5 u |
| Symbolic integration to Risch class (CM1) | ci_risch_integrate | The first half of this domain's own stated roadmap. Today nx_calc_integrate is pattern-directed; the board's note reads "Wolfram Risch-plus is far deeper". Implement the Risch decision procedure for the elementary case over the exact-rational tower. ACCEPT: for each integrand the result is verified BY DIFFERENTIATION through the already-shipped nx_derive and must return to the original integrand exactly, so the oracle is our own independent organ and not the integrator grading itself -- AND, the load-bearing half, an integrand with no elementary antiderivative must return a PROOF OF NON-INTEGRABILITY rather than failing silently or returning an unevaluated form. A pattern table can fake the first half and cannot fake the second. | Organ | 3 u |
| Equation solving over general systems (CM2) after CM3 | cs_solve_system | The second half of the stated roadmap. Today nx_calc_solve handles linear and quadratic; the board's note reads "Wolfram and Sage solve general systems". Multivariate polynomial systems via a Groebner basis computed over EXACT RATIONALS, never floats, so the basis is reproducible bit-for-bit. ACCEPT: every returned root substitutes back into every original equation to exact zero through the existing rational organ, the solution COUNT is checked against Bezout for a system where the bound is tight, and a NEG-CONTROL inconsistent system returns the unit ideal and REFUSES by name instead of emitting an empty list that reads like no solutions. | Organ | 3 u |
| Curated computable data (CM5) | cd_curated_query | The third item in the verdict and the only axis on this board with no presence row, because the estate has none of it. Wolfram is the only column that ships it. Admit a bounded first slice as DATA rows rather than code -- physical constants with their units and their stated uncertainty, and the periodic table -- queryable through the existing units organ so a constant arrives dimensioned rather than bare. ACCEPT: a query returns the value, its unit and its uncertainty, every row carries a citation to the published source it came from, a dimensional mismatch in a computation using it REFUSES through the existing nx_units path, and a NEG-CONTROL query for an absent entity returns a NAMED absence rather than a zero. GREENFIELD, PROVEN NOT ASSUMED: nx_compute_data is absent from buildroot/runtime, matches=0 with corpus_complete=1 over 23,202 files. | Organ | 2 u |
Milestones
| Milestone | Rungs | Cumulative |
|---|---|---|
| C0 · The two concrete depth gaps closed | CM4,CM3 | 2.5 u |
| C1 · The stated roadmap headline shipped | CM1,CM2 | 8.5 u |
| C2 · Curated computable data | CM5 | 10.5 u |
Layer 3 · Engineering
How this is scored. Every Nishi mark is measured: the generator reads the real organ source on disk and requires the implementing symbol to exist (no self-grading). A watching tag names the organ and symbol contracted to close a gap — the mark flips itself on the next compare beat when that workstream ships, and the
comparewatch- plane row flips with it. The flip is necessary, not sufficient: it proves the symbol exists, never that the capability is good. The bar is the rung's pre-declared done-rule, proven by its gate — a symbol shipped without the behaviour behind it is a defect, and the flip is exactly what makes that defect visible instead of quiet. Competitor marks record documented capability presence — presence, not depth or scale. Adoption is measured too: every measured row carries where its organ stands on the estate's ladder (source → built → promoted → registered → invoked; libraries by importer reach minus validation importers; gates by the execution surfaces that run them). A row is fully adopted only at the top of its ladder; anything short is tagged partial with the exact remedy, so a build nobody promoted can no longer read as shipped. Census stamps: importers asof 1787849099, gate census asof 1787855507 (unix seconds; -1 = census absent).Capability matrix — measured against source
◉ leads / measured exceed● present◐ partial○ absent · click any capability for its evidence
| Capability | Nishi | Wolfram | SymPy | SageMath | Maxima |
|---|---|---|---|---|---|
Arbitrary-precision integersOpen — no implementing organ is measured for this axis yet. nx_bigint (bi_add) -- unbounded integers; all four peers have them too | ○ | ● | ● | ● | ● |
Exact rationalsMeasured:rat_norm exists in runtime/_hdl_build/nx_rational.nx, verified at emit. nx_rational (rat_norm and rat_gcd) -- exact fractions Adoption: LIB-GATE-ONLY importers=2 — PARTIAL: imported only by validation organs (gates, tests, benches): wire it into a shipping program. | ● | ● | ● | ● | ● |
Complex numbersMeasured:nx_cx_add exists in runtime/nx_complex.nx, verified at emit. nx_complex (nx_cx_add) Adoption: LIB-WIRED importers=2 nonval=1 — fully adopted (top of its ladder). | ● | ● | ● | ● | ● |
Symbolic differentiationMeasured:nx_deriv_chain_alloc exists in runtime/nx_derive.nx, verified at emit. nx_derive (chain rule); Wolfram deepest (D) Adoption: LIB-WIRED importers=23 nonval=18 — fully adopted (top of its ladder). | ● | ● | ● | ● | ● |
Numeric integrationMeasured:nx_integral_rect_sum exists in runtime/nx_integral.nx, verified at emit. nx_integral (Riemann sum); peers ship adaptive quadrature Adoption: LIB-WIRED importers=5 nonval=2 — fully adopted (top of its ladder). | ● | ● | ● | ● | ● |
Symbolic integrationMeasured:nx_calc_integrate exists in runtime/nx_calc_integrate.nx, verified at emit. nx_calc_integrate; Wolfram Risch-plus is far deeper Adoption: LIB-GATE-ONLY importers=1 — PARTIAL: imported only by validation organs (gates, tests, benches): wire it into a shipping program. | ● | ● | ● | ● | ● |
Series expansionMeasured:nx_calc_maclaurin exists in runtime/nx_calc_series.nx, verified at emit. nx_calc_series (Maclaurin); peers ship general Taylor and Laurent Adoption: LIB-GATE-ONLY importers=1 — PARTIAL: imported only by validation organs (gates, tests, benches): wire it into a shipping program. | ● | ● | ● | ● | ● |
Equation solvingMeasured:nx_calc_solve_quadratic exists in runtime/nx_calc_solve.nx, verified at emit. nx_calc_solve (linear and quadratic); Wolfram and Sage solve general systems Adoption: LIB-GATE-ONLY importers=1 — PARTIAL: imported only by validation organs (gates, tests, benches): wire it into a shipping program. | ● | ● | ● | ● | ● |
Linear algebra (vectors)Measured:nx_vec_add exists in runtime/nx_linalg.nx, verified at emit. nx_linalg (nx_vec_add) Adoption: LIB-GATE-ONLY importers=1 — PARTIAL: imported only by validation organs (gates, tests, benches): wire it into a shipping program. | ● | ● | ● | ● | ● |
MatricesMeasured:nx_matrix_alloc exists in runtime/nx_matrix.nx, verified at emit. nx_matrix (alloc and ops) Adoption: LIB-GATE-ONLY importers=2 — PARTIAL: imported only by validation organs (gates, tests, benches): wire it into a shipping program. | ● | ● | ● | ● | ● |
PolynomialsMeasured:nx_poly_mul exists in runtime/nx_poly.nx, verified at emit. nx_poly (mul, add, derivative, eval) Adoption: LIB-WIRED importers=3 nonval=1 — fully adopted (top of its ladder). | ● | ● | ● | ● | ● |
Computational geometryMeasured:nx_geom_hough_line exists in runtime/nx_geom.nx, verified at emit. nx_geom (Hough, orientation); Wolfram and Sage rich, SymPy geometry module partial, Maxima limited Adoption: LIB-WIRED importers=4 nonval=1 — fully adopted (top of its ladder). | ● | ● | ◐ | ● | ◐ |
Graph algorithmsMeasured:nx_graphalg_add_edge exists in runtime/nx_graphalg.nx, verified at emit. nx_graphalg; Sage wraps NetworkX and is rich, SymPy minimal, Maxima none in core Adoption: LIB-GATE-ONLY importers=1 — PARTIAL: imported only by validation organs (gates, tests, benches): wire it into a shipping program. | ● | ● | ◐ | ● | ○ |
ProbabilityMeasured:nx_prob_pr exists in runtime/nx_probability.nx, verified at emit. nx_probability (measure over omega); Wolfram deepest, Maxima via distrib package Adoption: LIB-GATE-ONLY importers=2 — PARTIAL: imported only by validation organs (gates, tests, benches): wire it into a shipping program. | ● | ● | ● | ● | ◐ |
Tensors and autodiffMeasured:ta_leaf exists in runtime/nx_autograd_tensor.nx, verified at emit. nx_autograd_tensor -- reverse-mode autograd; none of the CAS peers is autodiff-first Adoption: SOURCE-ONLY — PARTIAL: source exists, never compiled: /api/build it. | ● | ◐ | ◐ | ◐ | ○ |
Units and dimensional analysisMeasured:nx_dim_meter exists in runtime/nx_units.nx, verified at emit. nx_units (SI dimensions); Wolfram Quantity, SymPy physics.units, Maxima partial Adoption: LIB-GATE-ONLY importers=1 — PARTIAL: imported only by validation organs (gates, tests, benches): wire it into a shipping program. | ● | ● | ● | ● | ◐ |
SAT and constraint solvingMeasured:nx_sat_add_clause exists in runtime/nx_sat_solver.nx, verified at emit. nx_sat_solver (clauses); Wolfram SatisfiabilityInstances, Sage via cryptominisat, Maxima none Adoption: LIB-WIRED importers=7 nonval=3 — fully adopted (top of its ladder). | ● | ● | ◐ | ● | ○ |
Number theory (primality)Measured:nx_check_prop exists in runtime/nx_triangulation_number_theory.nx, verified at emit. nx_triangulation_number_theory; prime proofs Adoption: SOURCE-ONLY — PARTIAL: source exists, never compiled: /api/build it. | ● | ● | ● | ● | ● |
Automated theorem provingMeasured:nx_atp_to_derive exists in runtime/nx_atp_to_derive.nx, verified at emit. nx_atp_to_derive -- ATP to derivation; none of the four is a general ATP Adoption: LIB-GATE-ONLY importers=1 — PARTIAL: imported only by validation organs (gates, tests, benches): wire it into a shipping program. | ● | ◐ | ○ | ◐ | ○ |
Autoformalization (informal to formal)Open — no implementing organ is measured for this axis yet. nx_autoformalize rung 1: informal words to Peano terms with a kernel-checked derivation. Wolfram Alpha parses natural-language math over a far broader grammar but emits no checked proofs | ○ | ◐ | ○ | ○ | ○ |
Peano and foundational arithmeticMeasured:nx_arith_mult exists in runtime/nx_arith.nx, verified at emit. nx_arith (successor, plus, mult from the axioms) Adoption: LIB-WIRED importers=3 nonval=1 — fully adopted (top of its ladder). | ● | ● | ● | ● | ● |
Symbolic integration to Risch classOpen — watchingruntime/nx_calc_integrate.nx : ci_risch_integrate, re-measured on every compare beat. Ship that symbol and this mark flips itself; the comparewatch- plane row flips with it. OPEN -- rung CM1, and the first half of this page's own stated roadmap. The presence row above grades every column 1 because all four peers do integrate symbolically; the deficit its note names is DEPTH -- "Wolfram Risch-plus is far deeper". The contract is the Risch decision procedure for the elementary case, which is the difference between a table of patterns and an algorithm that returns a proof of non-integrability when no elementary antiderivative exists | ○ | ● | ● | ● | ● |
Equation solving over general systemsOpen — watchingruntime/nx_calc_solve.nx : cs_solve_system, re-measured on every compare beat. Ship that symbol and this mark flips itself; the comparewatch- plane row flips with it. OPEN -- rung CM2, the second half of the stated roadmap. Today nx_calc_solve handles linear and quadratic; the row above names the gap as "Wolfram and Sage solve general systems". The contract is multivariate polynomial systems with a Groebner-basis path, and because this stack is integer-exact the basis is computed over exact rationals rather than floating point | ○ | ● | ● | ● | ● |
Series expansion to general Taylor and LaurentOpen — watchingruntime/nx_calc_series.nx : cs_series_laurent, re-measured on every compare beat. Ship that symbol and this mark flips itself; the comparewatch- plane row flips with it. OPEN -- rung CM3. Today the organ ships Maclaurin only, expansion about zero; the row above names the gap as "peers ship general Taylor and Laurent". The contract is expansion about an arbitrary point plus negative powers, which is what makes residues and pole analysis reachable at all | ○ | ● | ● | ● | ● |
Adaptive quadrature with an error boundOpen — watchingruntime/nx_integral.nx : ni_quad_adaptive, re-measured on every compare beat. Ship that symbol and this mark flips itself; the comparewatch- plane row flips with it. OPEN -- rung CM4. Today the organ ships a Riemann rectangle sum; the row above names the gap as "peers ship adaptive quadrature". The contract is subdivision driven by a measured local error estimate that REFUSES rather than silently returning a wrong answer when the requested tolerance cannot be met on the given interval | ○ | ● | ● | ● | ● |
Curated computable dataOpen — watchingruntime/nx_compute_data.nx : cd_curated_query, re-measured on every compare beat. Ship that symbol and this mark flips itself; the comparewatch- plane row flips with it. OPEN -- rung CM5, the third item this page's @verdict names and the only one with no presence row above it, because the estate has none of it. Cells are the verdict's own words: Wolfram is Best on curated computable data and no other column ships it, which is why this is the one row here whose rivals are not all equal. GREENFIELD PATH, PROVEN ABSENT rather than assumed: glob nx_compute_data over buildroot/runtime returns matches=0 with corpus_complete=1 over 23,202 files | ○ | ◉ | ○ | ○ | ○ |
| Where we lead | |||||
Sovereign, bits-up (own language, compiler and syscalls; zero third-party runtime)Measured exceed:sd_contains in runtime/nx_sovereign_deps_gate.nx, verified at emit. Nishi computes with NO Python, C, Lisp or cloud runtime beneath it. MEASURED BY THE ESTATE-WIDE INCUMBENT: nx_sovereign_deps_gate scans for the foreign-dependency markers (dlopen, include, openssl, libpcap, .so) across the whole tree, replacing the one-file dlopen check the retired bespoke generator carried inline -- a strictly wider ruler over 22,986 sources rather than a duplicate of it. Wolfram is proprietary and cloud-tethered; the others sit on large dependency stacks Adoption: GATE:BUILT-UNPROMOTED trial=- — PARTIAL: compiled, never promoted to the serving root: /api/promote it, then roster it. | ◉ | ○ | ○ | ○ | ◐ |
No-float, integer-deterministic by construction (bit-identical, reproducible)Measured exceed:rat_gcd in runtime/_hdl_build/nx_rational.nx, verified at emit. Nishi results are exact-integer and reproducible bit-for-bit; every peer defaults to floating point, so results vary with platform, compiler flags and library version Adoption: LIB-GATE-ONLY importers=2 — PARTIAL: imported only by validation organs (gates, tests, benches): wire it into a shipping program. | ◉ | ◐ | ◐ | ◐ | ◐ |
Risk register
| Risk | Likelihood x impact | Mitigation |
|---|---|---|
| A depth rung returns a confident wrong answer, which is the failure mode of every CAS | possible x catastrophic | Every accept rule above names an EXTERNAL or INDEPENDENT oracle rather than a self-graded pass: CM1 verifies by differentiating through a different organ, CM2 substitutes back through the rational organ and checks the root count against Bezout, CM3 cross-checks the residue against a contour value, CM4 must contain the known exact value. A symbolic result that grades itself has proven nothing. |
| A float is introduced to make an algorithm easier and the determinism exceed is silently lost | possible x high | No-float integer determinism is one of only two declared exceeds on this board. CM2 and CM4 are the two rungs where the temptation is real, and both accept rules are stated in exact arithmetic, so a floating implementation cannot satisfy them: an exact-zero substitution and a containing interval are not reachable by an implementation that has already rounded. |
| Curated data grows without bound and becomes a maintenance corpus nobody can cite | likely x medium | CM5 is scoped to a bounded first slice, constants and the periodic table, and every row must carry a citation to its published source. An entry with no citation is not admitted, and an absent entity returns a named absence rather than a zero, so the corpus can never quietly answer for something it does not hold. |
| The estimates here are carried from other lanes and are read as measurements | certain x medium | The unit row says so in its own words and the figures republish as actual-against-estimate on the first landed rung. Until then they are a bound, and the cheapest rung is deliberately sequenced first so the calibration arrives early rather than after the two hardest rungs. |
On these two registers. Rows are declared in the domain's plan file and carry the debt id, which is the join key back to the sovereign debt plane — that plane, not this page, is the authority on state. Reconciling them automatically (the regen reading the plane and refreshing these rows) is a named, owed rung; until it lands, treat an id here as a pointer to look up, not a status to trust.
Honest verdict. Nishi has broad computational presence -- a real organ in every core category above, built bits-up in one sovereign language. It is not a depth rival to Wolfram: Wolfram leads depth (10,000+ curated functions plus computable curated data) in nearly every row, and the general symbolic engines (SymPy, SageMath, Maxima) go deeper on symbolic integration and solving. Nishi's genuine exceeds are exactly two, and both are structural rather than depth claims: sovereign bits-up computation and no-float integer determinism. The roadmap is depth, not breadth -- deepen symbolic integration and solving, and add curated computable data. Two companion surfaces sit beside this page, linked here so that migrating off the retired bespoke generator does not orphan them: the Frontier Radar (researcher-fed momentum over a 1.94 MB corpus) and the Run-and-Compare Bench (18 of 18 executed-correct across 4 organ families).
Person · product · place — not yet measured for this domain
Every compare carries this layer. Declare
knowledge/compare/computational.ppp (rows surface|nishi or c1..c4|label|url|connect naming OUR live surface and each rival's front door), run nx_ppp_probe domain computational, and this section fills itself on the next beat: the same ruler on both sides — privacy and CX (third-party hosts, tracker classes, cookies, security headers), design and longevity (design hygiene, computed WCAG contrast, render-blocking resources, unsized media, script weight, theme and motion queries), findability (landmarks, skip link, on-site search, breadcrumb, headings, internal links).generated by nx_swcompare_matrix (sovereign NishiLang organ) from knowledge/compare/computational.matrix · every Nishi cell verified against organ source at emit time · watch cells re-measured on every compare beat · zero JS, zero trackers