Nishi Family › Compare › Computational Mathematics

Nishi Compare · capabilities, evidence and delivery

Computational Mathematics

Compare capabilities and delivery evidence. Source discovery, qualification, deployment and accepted outcomes are separate; an open contract names work still to verify.

Nishi sovereign integer computational-mathematics stack vs Wolfram Language and SymPy and SageMath and Maxima -- capability PRESENCE measured against real organ source, not depth

Overview

The purpose, declared position and evidence coverage of this domain. Source presence and completed acceptance are different measures.

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.

Latest recorded release

2026-09-03 · CM0

nx_mathcore_gate EXTENDED to the full math core: 18 to 31 teeth, GREEN 31 of 31 on the laptop toolchain, source landed on the NAS under a CONTENT compare-and-swap (14295 B, sha d5afe3e3). New teeth: complex addition componentwise, i squared equals minus one (the identity that defines the complex numbers), z times its conjugate equals the squared modulus and is purely real, DISTRIBUTIVITY over the complex numbers computed two ways, and raising to the second power agreeing with multiplying by itself (two independent code paths); plus the DERIVATION VERIFIER, whose six teeth are all REFUSALS because a checker that accepts everything would pass a well-formed-chain tooth and prove nothing -- a chain concluding nothing is refused as having no theorem, an empty chain is refused rather than vacuously accepted, an axiom citation naming no real axiom is refused AT INSERT, an unknown inference rule is refused, and a step whose premise does not exist yet is refused so the chain stays topological. Complex equality is bite-proven as a third comparator.

Release history and work log

Release entries describe recorded changes; they do not establish that every capability passed evaluation.

24 of 28 capability source symbols found|2 of them authored stronger-claims|4 open|coverage 857/1000|adoption 11 full / 13 partial

Evidence profile — what the gaps on this board actually are

Measured by nx_swcompare_evidence, read back by nx_evprofile_lib. Every figure is a count with its denominator — there is deliberately no score, no grade and no percentage anywhere in this band, because a stored scalar is a field a seat can edit and a counted partition is not.

proven able to fail counts the gates that have a RECORDED RED — nx_gate_bite mutated the gate subject, rebuilt it, watched the gate go red, and that record is inside the shared TTL. never bitten is its complement over the same denominator: those gates ran and were green, and nothing has ever shown them able to detect anything, so their green is a statement about this run and not about the gate. green at 0/0 is a separate and much weaker observation — the gate printed GREEN on a zero denominator, so its own tooth counter says it examined nothing. A gate can be green, non-zero, and still never bitten; that is the common case and it is now visible instead of implied.

partition: grounded + unsupported = 24 vs present 24 · named + unnamed + withheld = 4 vs open 4 · both reconcile

liar-kill conj=GPQN · all four conjuncts held

graded document: BUILDROOT tree, 11293 bytes · gates map: PRIMARY · stamped 35d 4h ago · STALE against the shared TTL of 604800s — this is evidence about a build nobody can vouch for now · source ../knowledge/status/evstamp_computational.verdict

Gap class	What it is, and the work it names
STALE	This profile is older than the shared TTL, or its clock ran backwards. It is reported as unusable rather than as fresh, because being wrong in the direction of refusing is the safe direction.

This band reports the referee counts. The per-axis worklist rows — which axis is unsupported, which watch is ready to flip, which gap is unnamed — are printed by nx_swcompare_evidence computational itself and are not carried on the stamp, so this page names the classes and the producer names the rows. That split is stated rather than hidden: a count without a worklist is not actionable, and this band is honest about which half of that it is.

Production map

Follow the dependencies, declared acceptance criteria and recorded priorities. Inspect source binding before treating a rank as executable work.

Ranking source binding: PLAN_MATRIX_BOUND_ONLY. Recorded priorities require current acceptance evidence and resource checks before execution.

Ranking matches the captured plan and matrix only. Latest execution outcome, research freshness, accepted delivery and investment return are unverified.

Recorded priority estimates

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: listed before new work by this heuristic. Priority is not measured delivery cost or execution readiness. Stamp: # asof=1790081980 domain=computational target_version=0.1 rungs=6 done=1 open=5 finish=1 ranker=nx_dr_ocm

#	Stage	Rung	Priority	Derivation
F	FINISH	Adaptive quadrature with an error bound (CM4) ni_quad_adaptive dossier	LIB-GATE-ONLY importers=1	imported only by validation organs (gates, tests, benches): wire it into a shipping program
#1	0.1	General Taylor and Laurent series (CM3) cs_series_laurent dossier	1000	v=15 m=1 c=15
#2	later	Symbolic integration to Risch class (CM1) ci_risch_integrate dossier	133	v=4 m=1 c=30
#3	later	Equation solving over general systems (CM2) cs_solve_system dossier	133	v=4 m=1 c=30
#4	later	Curated computable data (CM5) cd_curated_query dossier	100	v=2 m=1 c=20
#5	later	Board-level journal anchor for computational (CM0) - dossier	0	v=0 m=1 c=100

Declared roadmap — contract, acceptance, executor, effort

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

Rung	Closes with	Definition of done (pre-declared)	Executor	Est.
Board-level journal anchor for computational (CM0)	-	BOARD-LEVEL JOURNAL ANCHOR, DECLARED 2026-09-04. This board already journals 8 log rows against the id CM0, meaning the entry is about the BOARD rather than about one rung. The .plan schema says a log row's third field is a rung id, so until this row existed every one of those entries resolved to nothing and a session inheriting this board read a ledger pointing at an address that was never declared. Declaring the anchor is the additive fix: it changes no existing row, it makes the convention READABLE instead of implicit, and nx_board_idref_gate now resolves those entries instead of counting them as dangling. Journal board-wide findings here; journal rung work against its rung.	Board	0 u

Ladder verdict. NOT DECLARED. This board names no dated best-in-class or frontier target and no rung roles (sotatarget and rungrole rows on its plan); the ranker labels it NO-LADDER until it does, and until then its rungs climb toward a target nobody has written down. Bars read NO-BAR against the current month 2026-10.

Bar freshness, counted
Class	Count	Note
bars	0	sotabar rows on the plan
fresh	0	the bar month is the current month
attested	0	an older bar with a this-month barscan reporting no newer entry
stale	0	a this-month scan saw a newer month the bar ignores
unattested	0	nobody looked this month
malformed	0	a sotabar row missing a field
duplicate	0	bar ids an earlier row already carries
bars, summed	0	RECONCILED: the parts sum to the total 0
current month	2026-10	the month every bar is judged against

Treatment verdict. NOT DECLARED. No rung on this board declares its three-step treatment (a treat row naming the MCP row, the API route, the primitive it composes, the workflow that composes it and the agent beat that runs it); the ranker labels every rung TREATMENT-UNDECLARED until it does.

Inspect a rung and its prerequisites

Declared nodes 6. Rank input binding: PLAN_MATRIX_BOUND_ONLY. Dependency order is authored. Implementation, acceptance evidence, authority and resource readiness are unverified. No action is recommended or dispatched here.

Plan SHA-256 7c1dbd4f0e6be48499932bfbc26666e5ac4aebe799c80a1bc2a8591364335aaa. Target rows 0; role rows 0. Existing risks and release worklog retain their own scope; no node completion is inferred.

Runtime observation coverage: 0 of 6 rungs have current, identity-bound execution observations. Observation may report RED. Accepted completion remains unknown; source presence, qualification and deployment do not establish it.

Use Enter or Space on a rung to inspect its contract. Prerequisite links locate another rung in this list; open its summary to inspect it. Estimates are authored effort, not forecasts.

CM4 — Adaptive quadrature with an error bound
Prerequisites: None declared; this does not establish execution eligibility.
Contract: ni_quad_adaptive
Acceptance: 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.
Authored effort: 1. Executor kind: Organ. Responsible, accountable and verifier not established. Inspect retained worklog.
Runtime observation: UNKNOWN; outcome UNKNOWN; observed epoch -1. Declared owner: . Receipt , SHA-256 . Identity-bound observation is not accepted completion. Qualification and deployment remain unverified by this projection.
CM3 — General Taylor and Laurent series
Prerequisites: None declared; this does not establish execution eligibility.
Contract: cs_series_laurent
Acceptance: 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.
Authored effort: 1.5. Executor kind: Organ. Responsible, accountable and verifier not established. Inspect retained worklog.
Runtime observation: UNKNOWN; outcome UNKNOWN; observed epoch -1. Declared owner: . Receipt , SHA-256 . Identity-bound observation is not accepted completion. Qualification and deployment remain unverified by this projection.
CM1 — Symbolic integration to Risch class
Prerequisites: None declared; this does not establish execution eligibility.
Contract: ci_risch_integrate
Acceptance: 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.
Authored effort: 3. Executor kind: Organ. Responsible, accountable and verifier not established. Inspect retained worklog.
Runtime observation: UNKNOWN; outcome UNKNOWN; observed epoch -1. Declared owner: . Receipt , SHA-256 . Identity-bound observation is not accepted completion. Qualification and deployment remain unverified by this projection.
CM2 — Equation solving over general systems
Prerequisites: CM3 (acceptance unverified)
Contract: cs_solve_system
Acceptance: 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.
Authored effort: 3. Executor kind: Organ. Responsible, accountable and verifier not established. Inspect retained worklog.
Runtime observation: UNKNOWN; outcome UNKNOWN; observed epoch -1. Declared owner: . Receipt , SHA-256 . Identity-bound observation is not accepted completion. Qualification and deployment remain unverified by this projection.
CM5 — Curated computable data
Prerequisites: None declared; this does not establish execution eligibility.
Contract: cd_curated_query
Acceptance: 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.
Authored effort: 2. Executor kind: Organ. Responsible, accountable and verifier not established. Inspect retained worklog.
Runtime observation: UNKNOWN; outcome UNKNOWN; observed epoch -1. Declared owner: . Receipt , SHA-256 . Identity-bound observation is not accepted completion. Qualification and deployment remain unverified by this projection.
CM0 — Board-level journal anchor for computational
Prerequisites: None declared; this does not establish execution eligibility.
Contract: -
Acceptance: BOARD-LEVEL JOURNAL ANCHOR, DECLARED 2026-09-04. This board already journals 8 log rows against the id CM0, meaning the entry is about the BOARD rather than about one rung. The .plan schema says a log row's third field is a rung id, so until this row existed every one of those entries resolved to nothing and a session inheriting this board read a ledger pointing at an address that was never declared. Declaring the anchor is the additive fix: it changes no existing row, it makes the convention READABLE instead of implicit, and nx_board_idref_gate now resolves those entries instead of counting them as dangling. Journal board-wide findings here; journal rung work against its rung.
Authored effort: 0. Executor kind: Board. Responsible, accountable and verifier not established. Inspect retained worklog.
Runtime observation: UNKNOWN; outcome UNKNOWN; observed epoch -1. Declared owner: . Receipt , SHA-256 . Identity-bound observation is not accepted completion. Qualification and deployment remain unverified by this projection.

Learning and practice paths

No structured learning path is declared for this plan. Existing research, roadmap and worklog remain available above.

Rung dossiers — every record that bears on a rung, in one place

Joined by symbol, never typed. Each dossier is assembled on every publish from the rows this board already carries: the plan's rung row, the matrix row that carries its contract symbol (its status re-measured by the one symbol ruler), the gate the organ declares and the verdict the evidence referee recorded on its last run, the reference marks in the rung text, the design rows that name the rung and the work log filed against it. The capability matrix links each cell to its dossier and each dossier links back to its cell and forward to the rungs it stands on; a dependency naming no rung on this plan is written as UNRESOLVED rather than linked. Absences are named: NO-MATRIX-ROW, NO-GATE-DECLARED, UNRECORDED.

Gate verdicts: UNSTAMPED — no per-gate verdict artifact is published for this domain yet (nx_swcompare_evidence computational writes it beside its stamp); every gate below reads UNRECORDED until it runs.

Gate declarations: knowledge/organ_gate.conf read from this working directory (1 rows) and from the estate root (196 rows); rows in both counted once: 0; declarations read: 197. Every declaration in either copy counts, so a stub beside the publisher can never hide the root.

CM4 Adaptive quadrature with an error bound · cell PRESENT · gate NO-GATE-DECLARED

Contract	`ni_quad_adaptive` · executor Organ · 1 u · stands on nothing
Definition of done	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.
Matrix cell	Adaptive quadrature with an error bound · `runtime/nx_quadrature.nx` · PRESENT decl
Gate	NO-GATE-DECLARED — `knowledge/organ_gate.conf` carries no row for `nx_quadrature`; declare `nx_quadrature TAB <gate>` and the ship loop proves it and the verdict lands here.
Work log	2026-09-03 land nx_quadrature ni_quad_adaptive shipped to the NAS; nx_quadrature_gate cd9603c7 promoted and registered, prove 14 of 14 GREEN. It compiled and ran on the LN37 plus LN38 toolchain 6cf44630 whose canary passed GREEN. 2026-09-03 measure Adaptive Simpson KATs: x squared on 0..1 and x cubed on 0..2 are Simpson-exact at 5 evaluations, 1 over 1 plus x squared reaches pi over 4 at 125 evaluations, 1 over 0.01 plus x squared reaches 20 atan 10 at 2433 evaluations, abs x resolves the kink at 9; every result landed inside its own reported Richardson error bound. 2026-09-03 lesson The f64 compare codegen cleared the op0-in-rax fact BEFORE the operand loads (LN37) so a G4-elided single-use operand was re-read from an unwritten slot, and it made a NaN sort as a total order (LN38) so n != n read false; both were latent for any f64 ordered compare of a loaded value and only the CM4 NaN neg-control surfaced them.

CM3 General Taylor and Laurent series · cell WATCHING · gate NO-GATE-DECLARED

Contract	`cs_series_laurent` · executor Organ · 1.5 u · stands on nothing
Definition of done	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.
Matrix cell	Series expansion to general Taylor and Laurent · `runtime/nx_calc_series.nx` · WATCHING decl
Gate	NO-GATE-DECLARED — `knowledge/organ_gate.conf` carries no row for `nx_calc_series`; declare `nx_calc_series TAB <gate>` and the ship loop proves it and the verdict lands here.
Work log	no log row names this rung yet

CM1 Symbolic integration to Risch class · cell WATCHING · gate NO-GATE-DECLARED

Contract	`ci_risch_integrate` · executor Organ · 3 u · stands on nothing
Definition of done	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.
Matrix cell	Symbolic integration to Risch class · `runtime/nx_calc_integrate.nx` · WATCHING decl
Gate	NO-GATE-DECLARED — `knowledge/organ_gate.conf` carries no row for `nx_calc_integrate`; declare `nx_calc_integrate TAB <gate>` and the ship loop proves it and the verdict lands here.
Work log	no log row names this rung yet

CM2 Equation solving over general systems · cell WATCHING · gate NO-GATE-DECLARED

Contract	`cs_solve_system` · executor Organ · 3 u · stands on CM3
Definition of done	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.
Matrix cell	Equation solving over general systems · `runtime/nx_calc_solve.nx` · WATCHING decl
Gate	NO-GATE-DECLARED — `knowledge/organ_gate.conf` carries no row for `nx_calc_solve`; declare `nx_calc_solve TAB <gate>` and the ship loop proves it and the verdict lands here.
Work log	no log row names this rung yet

CM5 Curated computable data · cell WATCHING · gate NO-GATE-DECLARED

Contract	`cd_curated_query` · executor Organ · 2 u · stands on nothing
Definition of done	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.
Matrix cell	Curated computable data · `runtime/nx_compute_data.nx` · WATCHING decl
Gate	NO-GATE-DECLARED — `knowledge/organ_gate.conf` carries no row for `nx_compute_data`; declare `nx_compute_data TAB <gate>` and the ship loop proves it and the verdict lands here.
Work log	no log row names this rung yet

CM0 Board-level journal anchor for computational · cell NO-MATRIX-ROW · gate NO-MATRIX-ROW

Contract	`-` · executor Board · 0 u · stands on nothing
Definition of done	BOARD-LEVEL JOURNAL ANCHOR, DECLARED 2026-09-04. This board already journals 8 log rows against the id CM0, meaning the entry is about the BOARD rather than about one rung. The .plan schema says a log row's third field is a rung id, so until this row existed every one of those entries resolved to nothing and a session inheriting this board read a ledger pointing at an address that was never declared. Declaring the anchor is the additive fix: it changes no existing row, it makes the convention READABLE instead of implicit, and nx_board_idref_gate now resolves those entries instead of counting them as dangling. Journal board-wide findings here; journal rung work against its rung.
Matrix cell	NO-MATRIX-ROW — no matrix row carries `-`; the ranker reads this rung as unmapped and no cell can flip for it. Add the row and the join completes on the next publish.
Gate	the gate join needs a matrix row: no organ is named for this rung
Work log	2026-09-03 land 2026-09-03: THIS BOARD HAD NO GATE OF ANY KIND. nx_catalog reported nx_bigint_gate, nx_rational_gate, nx_complex_gate AND nx_derive_gate all ABSENT -- no source, no binary, nothing promoted -- so the exact arithmetic these rows claim, and which the no-float determinism doctrine rests on, carried ZERO executable proof and the honesty census correctly graded the whole domain CLAIM-ONLY. Closed by nx_mathcore_gate (18 of 18 GREEN, first compile, reproduced on the NAS, sha 1c210a4c, promoted + twinned + registered) and declared in knowledge/compare/computational.gates. EVERY TOOTH IS AN ALGEBRAIC IDENTITY, WHICH IS ITS OWN ORACLE: a carry crossing a 32-bit limb, add-then-subtract returning the original, distributivity computed two different ways over five limbs and again over rationals, multiplicative identity and annihilator, a shift round-trip, a big-endian byte round-trip, an antisymmetric total order, one third plus one sixth EXACTLY one half, negative denominators canonicalised, a reciprocal product exactly one. Non-vacuity is asserted rather than assumed: the carry teeth assert the carry FIRED, and both comparators are bite-proven because a comparator that answers equal to everything would pass every identity above. 2026-09-03 retract A PUBLISHED ROW ON THIS BOARD ASSERTED COVERAGE NO FILE BACKED, and the admission gate named it: af_derive_sum was declared in runtime/nx_autoformalize.nx, which is a thin CLI holding only main(); the function lives at line 216 of runtime/nx_autoformalize_lib.nx, where a 2026-07-15 split had moved it. The capability was real the whole time and the PATH was wrong, which is the resolving-a-name-is-not-resolving-a-path defect: the row read as grounded to a human and as UNGROUNDED to the referee. Repointed, and the domain went ungrounded=1 to ungrounded=0. 2026-09-03 measure nx_domain_admit computational REFUSE to ADMIT the same day (the ungrounded row above plus a missing C2 declaration -- the rivals are a closed commercial system and three open distributions with no release feed banked, now declared UNPINNED in the matrix header rather than left silently unfalsifiable, and pinning SymPy, SageMath and Maxima through their public release registries is owed). nx_swcompare_evidence computational: CLAIM-ONLY to MEASURED-HONEST, present 24 grounded 24 ungrounded 0, absent 4 all named, gates_green 1 of 1, every partition reconciling (24 plus 4 equals 28). 2026-09-03 measure SECOND METHOD CLASS (C5 ABSENT to UNSIGNED-CANDIDATE, carrier knowledge/status/evclass_computational.conf): nx_mathcore emits a real 128-bit product as big-endian hex and CPython's own arbitrary-precision integers -- code we did not write and cannot influence -- adjudicated five operand pairs, AGREE 5 of 5 with zero disagreements including 6148914691236517205 times 999999999999999989 whose product is 121 bits; the same witness handed the product with ONE hex digit flipped REFUSED it, so it can disagree and did. UNSIGNED because attestation needs an operator-registered durable key: evidence, not yet proof. 2026-09-03 queue OWED on this board: nx_mathcore_gate is NEVER-BITTEN because nx_gate_bite returned UNPROVEN BUILD-REFUSED-BY-ADMISSION (the box was busy; admission re-measures every call, so this is a fact about that run and not about the gate) -- re-run when load clears. Complex numbers and the derivation chains are STILL UNGATED and deliberately not claimed: nx_complex imports the syscalls.nx twin rather than nx_syscalls.nx, so folding it into this gate needs that import question settled first. 2026-09-03 retract THE IMPORT BLOCKER I NAMED IN THE LINE ABOVE WAS NOT A BLOCKER, AND READING THE FILE REFUTED IT IN ONE CALL. runtime/syscalls.nx is a 967-byte ALIAS STUB whose entire body is `import "nx_syscalls.nx"`, and its own header states the case: consumers resolve through NishiLang textual import splicing with path-dedup, so the canonical surface is spliced once and there are NO duplicate symbols -- it records that this very mechanism fixed a duplicate-symbol link error on 2026-05-19. I had inferred a fork from two import NAMES without opening either file. ★★★★★A BLOCKER ASSERTED FROM A NAME RATHER THAN FROM THE FILE IS A GUESS WEARING A MEASUREMENT'S CLOTHES, AND IT COSTS THE NEXT READER THE SAME FALSE DETOUR. 2026-09-03 land nx_mathcore_gate EXTENDED to the full math core: 18 to 31 teeth, GREEN 31 of 31 on the laptop toolchain, source landed on the NAS under a CONTENT compare-and-swap (14295 B, sha d5afe3e3). New teeth: complex addition componentwise, i squared equals minus one (the identity that defines the complex numbers), z times its conjugate equals the squared modulus and is purely real, DISTRIBUTIVITY over the complex numbers computed two ways, and raising to the second power agreeing with multiplying by itself (two independent code paths); plus the DERIVATION VERIFIER, whose six teeth are all REFUSALS because a checker that accepts everything would pass a well-formed-chain tooth and prove nothing -- a chain concluding nothing is refused as having no theorem, an empty chain is refused rather than vacuously accepted, an axiom citation naming no real axiom is refused AT INSERT, an unknown inference rule is refused, and a step whose premise does not exist yet is refused so the chain stays topological. Complex equality is bite-proven as a third comparator. 2026-09-03 measure HONEST SCOPE OF WHAT THE NAS CURRENTLY PROVES: the PROMOTED nx_mathcore_gate artifact is still the 18-tooth build, so nx_swcompare_evidence will report 18 of 18 until the 31-tooth build lands. The NAS build was REFUSED-BUILD-ADMIT (rc=4) and the ship queued row BQ-nx_mathcore_gate rather than forcing it: measured at that moment, load_centi=1981 against a 4000 ceiling with D-state 18 of 780 processes, the blocked set being seg-store writers (three nx_store_put, two nx_store_catalog, two nx_fsops_write). The 31 of 31 is a LAPTOP result on byte-identical source and is recorded as exactly that, never as a NAS verdict.

dossiers=6 cells_joined=5 no_matrix_row=1 (sum 6) gates_recorded=0 gates_unrecorded=0 no_gate_declared=5 (sum 5 of cells_joined) evgates=UNSTAMPED

Capability comparisons

Compare the field, search individual capabilities and open their source and adoption evidence. Documented presence does not establish comparative quality.

Position map — centrality and distinctiveness

The four-quadrant map the field uses for brand strategy (Dawar and Bagga, HBR June 2015), re-derived from this matrix on every publish. Centrality is the share of the category's feature mass a player covers, each feature weighted by how many hold it; distinctiveness is the average lead over each rival on the rows the player holds; breadth is the depth-weighted share of the whole matrix (the bubble); depth is how deeply the rows held are held; momentum is the day-over-day move off the spine (green rising, red falling, grey until day two); the dashed path runs first day → previous day → today. Dividers are the category means. Axes are fitted to the field of play, so read the tick numerals, not the frame. Rival marks are documented presence, so a rival's position reads the record, never its quality. The picture grades its own readability below; the table beside it is the same data for a screen reader or a second method.

Rows. 28 feature rows mapped of 28 matrix rows; 0 substrate rows (kernels, bounds and instruments the plan's rungrole marks substrate) are the estate's scaffolding, not category features, and stay off the map

Views. 2D cut: centrality, distinctiveness · 3D cube: centrality, distinctiveness, breadth · axes registered: centrality, distinctiveness, breadth, depth, momentum · a board picks its own in knowledge/compare/computational.cdmap (cut|x|y, cube|x|y|z); absent = the HBR defaults

bubble area = breadth · ring = momentum (green rising, red falling, grey until day two) · dashed = category means · axes fitted to the field of play: centrality 825–1000, distinctiveness 0–200 of 0–1000 permil (the full range put every player in one corner)
readability of the 2D cut, self-graded by the layout ruler: label overlaps 0 · labels over marks 0 · off-canvas 0 · unresolved labels 0 · mark overlaps 0 (a fact of the data: two players that close are that close) · data spread 696 permil of the plot · quadrant words unseated 0
text contrast, measured with wcag2-ratio (floors from contrast.conf), light theme: labels 16.24 (floor 4.50) · notes 16.24 (floor 4.50) · quadrant words 5.89 (floor 4.50) · tick numerals 5.89 (floor 4.50) · axis titles 5.59 (floor 4.50) · dark theme: labels 13.78 (floor 4.50) · quadrant words 5.55 (floor 4.50) · axis titles 5.97 (floor 4.50) · dark classes under their floor 0 (one figure serves both themes: a dark shortfall is a token to fix, never a class to hide) · classes refused under their floor 0 (a refused class is not drawn; the scale classes are measured, never hidden) · export: SVG PNG (receipt, rendered by the estate's own rasteriser from this page)

axes fitted: centrality 825–1000 · distinctiveness 0–200 · breadth 400–650 permil · farther bubbles are painted first, nearer ones over them · the floor shadow is each bubble's (x, y) at height 0
readability of the 3D cube, self-graded by the layout ruler: label overlaps 0 · labels over marks 0 · off-canvas 0 · unresolved labels 0 · mark overlaps 3 (a fact of the data: two players that close are that close) · data spread 253 permil of the plot

Nishi Wolfram SymPy SageMath Maxima
10 panels over 5 registered axes, every pair once (the lower axis on x, the higher on y) · each panel fitted to its own field of play, first and last tick numerals shown · no labels in a small cut, the legend names the colours; the grade below reports the mark terms only (MM summed over the panels, spread averaged)
readability of the small multiples, self-graded by the layout ruler: label overlaps 0 · labels over marks 0 · off-canvas 0 · unresolved labels 0 · mark overlaps 5 (a fact of the data: two players that close are that close) · data spread 510 permil of the plot

Player	Quadrant	centrality	distinctiveness	breadth	depth	momentum	Rows held	Days on spine	First seen
Nishi	Unconventional	893	163	595	694	0 since 2026-09-23	24	10	2026-09-15
Wolfram	Aspirational	983	104	607	629	0 since 2026-09-23	27	10	2026-09-15
SymPy	Mainstream	934	38	511	597	0 since 2026-09-23	24	10	2026-09-15
SageMath	Mainstream	959	63	559	626	0 since 2026-09-23	25	10	2026-09-15
Maxima	Peripheral	852	34	464	590	0 since 2026-09-23	22	10	2026-09-15

Day	Matrix rows reviewed	Players recorded
2026-09-15	28	5
2026-09-16	28	5
2026-09-17	28	5
2026-09-18	28	5
2026-09-19	28	5
2026-09-20	28	5
2026-09-21	28	5
2026-09-22	28	5
2026-09-23	28	5
2026-10-08	28	5

How to read this evidence. A Nishi source mark records whether the named symbol is declared in the selected source file. It does not establish working behavior or accepted delivery. A watching tag names an expected source entry; discovering it updates source coverage only. A dark tag means the file exists but the named symbol was not found: inspect the source and contract before assuming the capability is missing or renaming code. Peer codes are authored assessments; unassessed means no comparison is established, not absence. Qualification, deployment identity, runtime observations and acceptance must carry their own evidence. Adoption records the catalog's observed path through source, build, promotion, registration and invocation; libraries use importer evidence and gates use declared execution surfaces. A full catalog path does not establish quality, freshness or a successful user outcome. Partial and unknown states retain their stated next action. Census stamps: importers asof 1790637268, gate census asof 1790104131 (unix seconds; -1 = census absent).

Capability matrix — measured against source

◉ authored stronger claim; source present● present◐ partial○ absent? unassessed; excluded from relative comparison · click any capability for its evidence

Peer cell coverage: authored assessed 112, unassessed 0. Authored assessments are not verified outcomes.

Capability	Nishi	Wolfram	SymPy	SageMath	Maxima
Arbitrary-precision integers Measured: `bi_add` exists in `runtime/nx_bigint_lib.nx`, verified at emit. nx_bigint (bi_add) -- unbounded integers; all four peers have them too rival marks uncited — the Yes, Best or Part codes on this row are an observation read with no reference mark behind them Adoption: `LIB-WIRED importers=5 nonval=3` — fully adopted (top of its ladder). Pros Implementing source symbol found; runtime acceptance separate; fully adopted on the estate ladderCons none on the measured axes (rival marks are documented presence, not depth)	●	●	●	●	●
Exact rationals Measured: `rat_norm` exists in `runtime/_hdl_build/nx_rational.nx`, verified at emit. nx_rational (rat_norm and rat_gcd) -- exact fractions rival marks uncited — the Yes, Best or Part codes on this row are an observation read with no reference mark behind them Adoption: `LIB-GATE-ONLY importers=3` — PARTIAL: imported only by validation organs (gates, tests, benches): wire it into a shipping program. not adopted: imported only by validation organs (gates, tests, benches): wire it into a shipping program Pros Implementing source symbol found; runtime acceptance separateCons not adopted yet: imported only by validation organs (gates, tests, benches): wire it into a shipping program	●	●	●	●	●
Complex numbers Measured: `nx_cx_add` exists in `runtime/nx_complex.nx`, verified at emit. nx_complex (nx_cx_add) rival marks uncited — the Yes, Best or Part codes on this row are an observation read with no reference mark behind them Adoption: `LIB-WIRED importers=3 nonval=1` — fully adopted (top of its ladder). Pros Implementing source symbol found; runtime acceptance separate; fully adopted on the estate ladderCons none on the measured axes (rival marks are documented presence, not depth)	●	●	●	●	●
Symbolic differentiation Measured: `nx_deriv_chain_alloc` exists in `runtime/nx_derive.nx`, verified at emit. nx_derive (chain rule); Wolfram deepest (D) rival marks uncited — the Yes, Best or Part codes on this row are an observation read with no reference mark behind them Adoption: `LIB-WIRED importers=24 nonval=18` — fully adopted (top of its ladder). Pros Implementing source symbol found; runtime acceptance separate; fully adopted on the estate ladderCons none on the measured axes (rival marks are documented presence, not depth)	●	●	●	●	●
Numeric integration Measured: `nx_integral_rect_sum` exists in `runtime/nx_integral.nx`, verified at emit. nx_integral (Riemann sum); peers ship adaptive quadrature rival marks uncited — the Yes, Best or Part codes on this row are an observation read with no reference mark behind them Adoption: `LIB-WIRED importers=6 nonval=3` — fully adopted (top of its ladder). Pros Implementing source symbol found; runtime acceptance separate; fully adopted on the estate ladderCons none on the measured axes (rival marks are documented presence, not depth)	●	●	●	●	●
Symbolic integration Measured: `nx_calc_integrate` exists in `runtime/nx_calc_integrate.nx`, verified at emit. nx_calc_integrate; Wolfram Risch-plus is far deeper [wolfram] Adoption: `LIB-GATE-ONLY importers=1` — PARTIAL: imported only by validation organs (gates, tests, benches): wire it into a shipping program. not adopted: imported only by validation organs (gates, tests, benches): wire it into a shipping program Pros Implementing source symbol found; runtime acceptance separateCons not adopted yet: imported only by validation organs (gates, tests, benches): wire it into a shipping program	●	●	●	●	●
Series expansion Measured: `nx_calc_maclaurin` exists in `runtime/nx_calc_series.nx`, verified at emit. nx_calc_series (Maclaurin); peers ship general Taylor and Laurent [sympy] Adoption: `LIB-GATE-ONLY importers=1` — PARTIAL: imported only by validation organs (gates, tests, benches): wire it into a shipping program. not adopted: imported only by validation organs (gates, tests, benches): wire it into a shipping program Pros Implementing source symbol found; runtime acceptance separateCons not adopted yet: imported only by validation organs (gates, tests, benches): wire it into a shipping program	●	●	●	●	●
Equation solving Measured: `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 [sage] Adoption: `LIB-GATE-ONLY importers=1` — PARTIAL: imported only by validation organs (gates, tests, benches): wire it into a shipping program. not adopted: imported only by validation organs (gates, tests, benches): wire it into a shipping program Pros Implementing source symbol found; runtime acceptance separateCons not adopted yet: 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) rival marks uncited — the Yes, Best or Part codes on this row are an observation read with no reference mark behind them Adoption: `LIB-WIRED importers=6 nonval=4` — fully adopted (top of its ladder). Pros Implementing source symbol found; runtime acceptance separate; fully adopted on the estate ladderCons none on the measured axes (rival marks are documented presence, not depth)	●	●	●	●	●
Matrices Measured: `nx_matrix_alloc` exists in `runtime/nx_matrix.nx`, verified at emit. nx_matrix (alloc and ops) rival marks uncited — the Yes, Best or Part codes on this row are an observation read with no reference mark behind them Adoption: `LIB-GATE-ONLY importers=4` — PARTIAL: imported only by validation organs (gates, tests, benches): wire it into a shipping program. not adopted: imported only by validation organs (gates, tests, benches): wire it into a shipping program Pros Implementing source symbol found; runtime acceptance separateCons not adopted yet: imported only by validation organs (gates, tests, benches): wire it into a shipping program	●	●	●	●	●
Polynomials Measured: `nx_poly_mul` exists in `runtime/nx_poly.nx`, verified at emit. nx_poly (mul, add, derivative, eval) rival marks uncited — the Yes, Best or Part codes on this row are an observation read with no reference mark behind them Adoption: `LIB-WIRED importers=3 nonval=1` — fully adopted (top of its ladder). Pros Implementing source symbol found; runtime acceptance separate; fully adopted on the estate ladderCons none on the measured axes (rival marks are documented presence, not depth)	●	●	●	●	●
Computational geometry Measured: `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 rival marks uncited — the Yes, Best or Part codes on this row are an observation read with no reference mark behind them Adoption: `LIB-WIRED importers=4 nonval=1` — fully adopted (top of its ladder). Pros Implementing source symbol found; runtime acceptance separate; ahead of SymPy, Maxima; fully adopted on the estate ladderCons none on the measured axes (rival marks are documented presence, not depth)	●	●	◐	●	◐
Graph algorithms Measured: `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 rival marks uncited — the Yes, Best or Part codes on this row are an observation read with no reference mark behind them Adoption: `LIB-WIRED importers=2 nonval=1` — fully adopted (top of its ladder). Pros Implementing source symbol found; runtime acceptance separate; ahead of SymPy, Maxima; fully adopted on the estate ladderCons none on the measured axes (rival marks are documented presence, not depth)	●	●	◐	●	○
Probability Measured: `nx_prob_pr` exists in `runtime/nx_probability.nx`, verified at emit. nx_probability (measure over omega); Wolfram deepest, Maxima via distrib package [maxima] Adoption: `LIB-GATE-ONLY importers=2` — PARTIAL: imported only by validation organs (gates, tests, benches): wire it into a shipping program. not adopted: imported only by validation organs (gates, tests, benches): wire it into a shipping program Pros Implementing source symbol found; runtime acceptance separate; ahead of MaximaCons not adopted yet: imported only by validation organs (gates, tests, benches): wire it into a shipping program	●	●	●	●	◐
Tensors and autodiff Measured: `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 rival marks uncited — the Yes, Best or Part codes on this row are an observation read with no reference mark behind them Adoption: `SOURCE-ONLY` — PARTIAL: source exists, never compiled: /api/build it. not adopted: source exists, never compiled: /api/build it Pros Implementing source symbol found; runtime acceptance separate; ahead of Wolfram, SymPy, SageMath, MaximaCons not adopted yet: source exists, never compiled: /api/build it	●	◐	◐	◐	○
Units and dimensional analysis Measured: `nx_dim_meter` exists in `runtime/nx_units.nx`, verified at emit. nx_units (SI dimensions); Wolfram Quantity, SymPy physics.units, Maxima partial rival marks uncited — the Yes, Best or Part codes on this row are an observation read with no reference mark behind them Adoption: `LIB-GATE-ONLY importers=1` — PARTIAL: imported only by validation organs (gates, tests, benches): wire it into a shipping program. not adopted: imported only by validation organs (gates, tests, benches): wire it into a shipping program Pros Implementing source symbol found; runtime acceptance separate; ahead of MaximaCons not adopted yet: imported only by validation organs (gates, tests, benches): wire it into a shipping program	●	●	●	●	◐
SAT and constraint solving Measured: `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 rival marks uncited — the Yes, Best or Part codes on this row are an observation read with no reference mark behind them Adoption: `LIB-WIRED importers=7 nonval=3` — fully adopted (top of its ladder). Pros Implementing source symbol found; runtime acceptance separate; ahead of SymPy, Maxima; fully adopted on the estate ladderCons none on the measured axes (rival marks are documented presence, not depth)	●	●	◐	●	○
Number theory (primality) Measured: `nx_check_prop` exists in `runtime/nx_triangulation_number_theory.nx`, verified at emit. nx_triangulation_number_theory; prime proofs rival marks uncited — the Yes, Best or Part codes on this row are an observation read with no reference mark behind them Adoption: `SOURCE-ONLY` — PARTIAL: source exists, never compiled: /api/build it. not adopted: source exists, never compiled: /api/build it Pros Implementing source symbol found; runtime acceptance separateCons not adopted yet: source exists, never compiled: /api/build it	●	●	●	●	●
Automated theorem proving Measured: `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 rival marks uncited — the Yes, Best or Part codes on this row are an observation read with no reference mark behind them Adoption: `LIB-GATE-ONLY importers=1` — PARTIAL: imported only by validation organs (gates, tests, benches): wire it into a shipping program. not adopted: imported only by validation organs (gates, tests, benches): wire it into a shipping program Pros Implementing source symbol found; runtime acceptance separate; ahead of Wolfram, SymPy, SageMath, MaximaCons not adopted yet: imported only by validation organs (gates, tests, benches): wire it into a shipping program	●	◐	○	◐	○
Autoformalization (informal to formal) Measured: `af_derive_sum` exists in `runtime/nx_autoformalize_lib.nx`, verified at emit. 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 rival marks uncited — the Yes, Best or Part codes on this row are an observation read with no reference mark behind them Adoption: `LIB-WIRED importers=3 nonval=2` — fully adopted (top of its ladder). Pros Implementing source symbol found; runtime acceptance separate; ahead of Wolfram, SymPy, SageMath, Maxima; fully adopted on the estate ladderCons none on the measured axes (rival marks are documented presence, not depth)	●	◐	○	○	○
Peano and foundational arithmetic Measured: `nx_arith_mult` exists in `runtime/nx_arith.nx`, verified at emit. nx_arith (successor, plus, mult from the axioms) rival marks uncited — the Yes, Best or Part codes on this row are an observation read with no reference mark behind them Adoption: `LIB-WIRED importers=3 nonval=1` — fully adopted (top of its ladder). Pros Implementing source symbol found; runtime acceptance separate; fully adopted on the estate ladderCons none on the measured axes (rival marks are documented presence, not depth)	●	●	●	●	●
Symbolic integration to Risch class DARK — `runtime/nx_calc_integrate.nx` EXISTS but does not declare `ci_risch_integrate`: something shipped at this path under another name, and this mark would read open forever. Repoint the contract to the real entry point (the plan rung AND this row) or rename the function; the flip follows on the next beat, and the `comparewatch-` plane row reads DARK until then. 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 rival marks uncited — the Yes, Best or Part codes on this row are an observation read with no reference mark behind them dossierwatching ci_risch_integrate Pros none measured yetCons behind Wolfram, SymPy, SageMath, Maxima; open contract; expected source declaration not established	○	●	●	●	●
Equation solving over general systems DARK — `runtime/nx_calc_solve.nx` EXISTS but does not declare `cs_solve_system`: something shipped at this path under another name, and this mark would read open forever. Repoint the contract to the real entry point (the plan rung AND this row) or rename the function; the flip follows on the next beat, and the `comparewatch-` plane row reads DARK until then. 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 rival marks uncited — the Yes, Best or Part codes on this row are an observation read with no reference mark behind them dossierwatching cs_solve_system Pros none measured yetCons behind Wolfram, SymPy, SageMath, Maxima; open contract; expected source declaration not established	○	●	●	●	●
Series expansion to general Taylor and Laurent DARK — `runtime/nx_calc_series.nx` EXISTS but does not declare `cs_series_laurent`: something shipped at this path under another name, and this mark would read open forever. Repoint the contract to the real entry point (the plan rung AND this row) or rename the function; the flip follows on the next beat, and the `comparewatch-` plane row reads DARK until then. 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 rival marks uncited — the Yes, Best or Part codes on this row are an observation read with no reference mark behind them dossierwatching cs_series_laurent Pros none measured yetCons behind Wolfram, SymPy, SageMath, Maxima; open contract; expected source declaration not established	○	●	●	●	●
Adaptive quadrature with an error bound Measured: `ni_quad_adaptive` exists in `runtime/nx_quadrature.nx`, verified at emit. LANDED 2026-09-03 rung CM4. Adaptive Simpson driven by a measured Richardson local-error estimate; it REFUSES rather than silently return a wrong answer when the tolerance cannot be met, and names bad input and a NaN integrand. Proven by nx_quadrature_gate 14 of 14 GREEN on the NAS against analytic KATs (x^2, x^3 Simpson-exact at the minimum 5 evaluations, pi over 4, a sharp peak forcing real subdivision, a kink) with neg-controls for an impossible tolerance, a reversed interval and a NaN integrand rival marks uncited — the Yes, Best or Part codes on this row are an observation read with no reference mark behind them Adoption: `LIB-GATE-ONLY importers=1` — PARTIAL: imported only by validation organs (gates, tests, benches): wire it into a shipping program. dossiernot adopted: imported only by validation organs (gates, tests, benches): wire it into a shipping program Pros Implementing source symbol found; runtime acceptance separateCons not adopted yet: imported only by validation organs (gates, tests, benches): wire it into a shipping program	●	●	●	●	●
Curated computable data Open — watching `runtime/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 rival marks uncited — the Yes, Best or Part codes on this row are an observation read with no reference mark behind them dossierwatching cd_curated_query Pros none measured yetCons behind Wolfram (leads); open contract; expected source declaration not established	○	◉	○	○	○
Where we lead
Sovereign, bits-up (own language, compiler and syscalls; zero third-party runtime) Source present; authored stronger claim: `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 rival marks uncited — the Yes, Best or Part codes on this row are an observation read with no reference mark behind them Adoption: `GATE:BUILT-UNPROMOTED trial=-` — PARTIAL: compiled, never promoted to the serving root: /api/promote it, then roster it. not adopted: compiled, never promoted to the serving root: /api/promote it, then roster it Pros Source symbol found; stronger capability claim is authored; ahead of Wolfram, SymPy, SageMath, MaximaCons not adopted yet: compiled, never promoted to the serving root: /api/promote it, then roster it	◉	○	○	○	◐
No-float, integer-deterministic by construction (bit-identical, reproducible) Source present; authored stronger claim: `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 rival marks uncited — the Yes, Best or Part codes on this row are an observation read with no reference mark behind them Adoption: `LIB-GATE-ONLY importers=3` — PARTIAL: imported only by validation organs (gates, tests, benches): wire it into a shipping program. not adopted: imported only by validation organs (gates, tests, benches): wire it into a shipping program Pros Source symbol found; stronger capability claim is authored; ahead of Wolfram, SymPy, SageMath, MaximaCons not adopted yet: imported only by validation organs (gates, tests, benches): wire it into a shipping program	◉	◐	◐	◐	◐

Rival-claim provenance. Every Yes, Best or Part mark in a rival column is a claim about someone else's product. A cited row carries a reference mark that resolves to a pinned mirror (the refs gate measures that); an uncited row is an observation read and is badged in its evidence until a reference lands. The badge is the receipt, never the proof: a mark proves a mirror exists, not that the mirror supports the code. The rows are counted below.

Rival claims, counted
Class	Count	Note
rows with rival marks	28	rows carrying a Yes, Best or Part in a rival column
cited	4	a reference mark resolves to a pinned mirror
uncited	24	an observation read, badged until a reference lands
rows, summed	28	RECONCILED: the parts sum to the total 28

Delivery and evidence

Inspect risks, technical debt, rendered observations, experiments and references. Read scope and limitations alongside every result.

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.

Release history and work log

The worked plan, on the board. Every leg appends what it measured, landed, retracted, learned and left queued, per rung, so a crash leaves the next seat a ledger here rather than a transcript to mine. Kinds: measure, land, retract, lesson, queue. Newest last.

When	Rung	Kind	Entry
2026-09-03	CM0	land	2026-09-03: THIS BOARD HAD NO GATE OF ANY KIND. nx_catalog reported nx_bigint_gate, nx_rational_gate, nx_complex_gate AND nx_derive_gate all ABSENT -- no source, no binary, nothing promoted -- so the exact arithmetic these rows claim, and which the no-float determinism doctrine rests on, carried ZERO executable proof and the honesty census correctly graded the whole domain CLAIM-ONLY. Closed by nx_mathcore_gate (18 of 18 GREEN, first compile, reproduced on the NAS, sha 1c210a4c, promoted + twinned + registered) and declared in knowledge/compare/computational.gates. EVERY TOOTH IS AN ALGEBRAIC IDENTITY, WHICH IS ITS OWN ORACLE: a carry crossing a 32-bit limb, add-then-subtract returning the original, distributivity computed two different ways over five limbs and again over rationals, multiplicative identity and annihilator, a shift round-trip, a big-endian byte round-trip, an antisymmetric total order, one third plus one sixth EXACTLY one half, negative denominators canonicalised, a reciprocal product exactly one. Non-vacuity is asserted rather than assumed: the carry teeth assert the carry FIRED, and both comparators are bite-proven because a comparator that answers equal to everything would pass every identity above.
2026-09-03	CM0	retract	A PUBLISHED ROW ON THIS BOARD ASSERTED COVERAGE NO FILE BACKED, and the admission gate named it: af_derive_sum was declared in runtime/nx_autoformalize.nx, which is a thin CLI holding only main(); the function lives at line 216 of runtime/nx_autoformalize_lib.nx, where a 2026-07-15 split had moved it. The capability was real the whole time and the PATH was wrong, which is the resolving-a-name-is-not-resolving-a-path defect: the row read as grounded to a human and as UNGROUNDED to the referee. Repointed, and the domain went ungrounded=1 to ungrounded=0.
2026-09-03	CM0	measure	nx_domain_admit computational REFUSE to ADMIT the same day (the ungrounded row above plus a missing C2 declaration -- the rivals are a closed commercial system and three open distributions with no release feed banked, now declared UNPINNED in the matrix header rather than left silently unfalsifiable, and pinning SymPy, SageMath and Maxima through their public release registries is owed). nx_swcompare_evidence computational: CLAIM-ONLY to MEASURED-HONEST, present 24 grounded 24 ungrounded 0, absent 4 all named, gates_green 1 of 1, every partition reconciling (24 plus 4 equals 28).
2026-09-03	CM0	measure	SECOND METHOD CLASS (C5 ABSENT to UNSIGNED-CANDIDATE, carrier knowledge/status/evclass_computational.conf): nx_mathcore emits a real 128-bit product as big-endian hex and CPython's own arbitrary-precision integers -- code we did not write and cannot influence -- adjudicated five operand pairs, AGREE 5 of 5 with zero disagreements including 6148914691236517205 times 999999999999999989 whose product is 121 bits; the same witness handed the product with ONE hex digit flipped REFUSED it, so it can disagree and did. UNSIGNED because attestation needs an operator-registered durable key: evidence, not yet proof.
2026-09-03	CM0	queue	OWED on this board: nx_mathcore_gate is NEVER-BITTEN because nx_gate_bite returned UNPROVEN BUILD-REFUSED-BY-ADMISSION (the box was busy; admission re-measures every call, so this is a fact about that run and not about the gate) -- re-run when load clears. Complex numbers and the derivation chains are STILL UNGATED and deliberately not claimed: nx_complex imports the syscalls.nx twin rather than nx_syscalls.nx, so folding it into this gate needs that import question settled first.
2026-09-03	CM0	retract	THE IMPORT BLOCKER I NAMED IN THE LINE ABOVE WAS NOT A BLOCKER, AND READING THE FILE REFUTED IT IN ONE CALL. runtime/syscalls.nx is a 967-byte ALIAS STUB whose entire body is `import "nx_syscalls.nx"`, and its own header states the case: consumers resolve through NishiLang textual import splicing with path-dedup, so the canonical surface is spliced once and there are NO duplicate symbols -- it records that this very mechanism fixed a duplicate-symbol link error on 2026-05-19. I had inferred a fork from two import NAMES without opening either file. ★★★★★A BLOCKER ASSERTED FROM A NAME RATHER THAN FROM THE FILE IS A GUESS WEARING A MEASUREMENT'S CLOTHES, AND IT COSTS THE NEXT READER THE SAME FALSE DETOUR.
2026-09-03	CM0	land	nx_mathcore_gate EXTENDED to the full math core: 18 to 31 teeth, GREEN 31 of 31 on the laptop toolchain, source landed on the NAS under a CONTENT compare-and-swap (14295 B, sha d5afe3e3). New teeth: complex addition componentwise, i squared equals minus one (the identity that defines the complex numbers), z times its conjugate equals the squared modulus and is purely real, DISTRIBUTIVITY over the complex numbers computed two ways, and raising to the second power agreeing with multiplying by itself (two independent code paths); plus the DERIVATION VERIFIER, whose six teeth are all REFUSALS because a checker that accepts everything would pass a well-formed-chain tooth and prove nothing -- a chain concluding nothing is refused as having no theorem, an empty chain is refused rather than vacuously accepted, an axiom citation naming no real axiom is refused AT INSERT, an unknown inference rule is refused, and a step whose premise does not exist yet is refused so the chain stays topological. Complex equality is bite-proven as a third comparator.
2026-09-03	CM0	measure	HONEST SCOPE OF WHAT THE NAS CURRENTLY PROVES: the PROMOTED nx_mathcore_gate artifact is still the 18-tooth build, so nx_swcompare_evidence will report 18 of 18 until the 31-tooth build lands. The NAS build was REFUSED-BUILD-ADMIT (rc=4) and the ship queued row BQ-nx_mathcore_gate rather than forcing it: measured at that moment, load_centi=1981 against a 4000 ceiling with D-state 18 of 780 processes, the blocked set being seg-store writers (three nx_store_put, two nx_store_catalog, two nx_fsops_write). The 31 of 31 is a LAPTOP result on byte-identical source and is recorded as exactly that, never as a NAS verdict.

Risk register

Risk	Likelihood x impact	Mitigation
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.

Release history continued

When	Rung	Kind	Entry
2026-09-03	CM4	land	nx_quadrature ni_quad_adaptive shipped to the NAS; nx_quadrature_gate cd9603c7 promoted and registered, prove 14 of 14 GREEN. It compiled and ran on the LN37 plus LN38 toolchain 6cf44630 whose canary passed GREEN.
2026-09-03	CM4	measure	Adaptive Simpson KATs: x squared on 0..1 and x cubed on 0..2 are Simpson-exact at 5 evaluations, 1 over 1 plus x squared reaches pi over 4 at 125 evaluations, 1 over 0.01 plus x squared reaches 20 atan 10 at 2433 evaluations, abs x resolves the kink at 9; every result landed inside its own reported Richardson error bound.
2026-09-03	CM4	lesson	The f64 compare codegen cleared the op0-in-rax fact BEFORE the operand loads (LN37) so a G4-elided single-use operand was re-read from an unwritten slot, and it made a NaN sort as a total order (LN38) so n != n read false; both were latent for any f64 ordered compare of a loaded value and only the CM4 NaN neg-control surfaced them.

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 <a href='/compare/computational/frontier'>Frontier Radar</a> (researcher-fed momentum over a 1.94 MB corpus) and the <a href='/compare/computational/bench'>Run-and-Compare Bench</a> (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).

The field — discovered, not chosen

Rows written by nx_field_discover from computational.seeds: the industry's own lists (Wikipedia wikitext, GitHub topics, awesome lists) read mechanically, every candidate counted across seeds. The matrix columns above are a SEAT'S pick; this band is the population they were picked from, and the stats line measures one against the other. A rival here is a lead, never a verdict — it earns a column when its capabilities are read and pinned.

Discovery receipt. One row per counter the run wrote, in the receipt's own order; the rival rows follow in their own table.

Field discovery, counted
Class	Count	Note
seeds	4
scanned	4
fetched	3
reused	1
failed	0
named	4
candidates	4
mentions	4
capped	0

Rank	Rival	Seeds	Mentions	First seed	Kind	Link
1	Wolfram	1	1	col0-wolfram	named	https://reference.wolfram.com/language/ref/Integrate.html
2	SymPy	1	1	col1-sympy	named	https://docs.sympy.org/latest/modules/integrals/integrals.html
3	SageMath	1	1	col2-sagemath	named	https://doc.sagemath.org/html/en/reference/calculus/index.html
4	Maxima	1	1	col3-maxima	named	https://maxima.sourceforge.io/documentation.html

Exclusive and shared capabilities

One capability is graded on one board; every other board references it. The fleet duplicate census (nx_rivalcensus dupes, on the fleetdupes clock row) reads every board's matrix and names each capability graded as a row on two or more boards, with a home derived from evidence: rung when exactly one board's plan contracts the symbol (that board is starred), gates when no plan contracts it and exactly one board's executed gate map runs the organ's gate (that board is plussed), ambiguous when several boards carry the deciding evidence (a decision for their seats), and none when no evidence decides it, with the reason beside it: unmapped (no board of the duplicate declares a gates map; declare the maps) or unproven (a map exists and runs none of the organ's gates; gate the organ on its proving board, or declare it a shared library by policy). A home elsewhere means this board should carry an @xrow reference to the home board's row rather than a graded row of its own; a home here means the other boards should. The table is this board's slice of one estate-wide census: the shape is shared, the rows are the board's.

This board grades 28 capabilities: 21 exclusive to it and 7 shared with other boards. Shared rows on this page: 7 = home here 1 + home elsewhere 0 + ambiguous 0 + undecided 6 + refused 0 (partition 7); undecided = unmapped 0 + unproven 6 + unevidenced 0; homonyms 0; since the previous census: new 0, resolved 0. Census FRESH age_s=6797.

Capability	Organ	Boards grading it	Home	Rule	Evidence	Standing on this board
nx_calc_integrate	`nx_calc_integrate.nx`	stem, lang, computational	—	none	unproven	undecided
nx_calc_solve_quadratic	`nx_calc_solve.nx`	stem, computational	—	none	unproven	undecided
ta_leaf	`nx_autograd_tensor.nx`	stem, computational	—	none	unproven	undecided
nx_check_prop	`nx_triangulation_number_theory.nx`	stem, computational	—	none	unproven	undecided
nx_matrix_alloc	`nx_matrix.nx`	computational, appliedmath	—	none	unproven	undecided
nx_dim_meter	`nx_units.nx`	computational, appliedmath	—	none	unproven	undecided
ni_quad_adaptive	`nx_quadrature.nx`	computational*, appliedmath	computational	rung	plan	home here

Gaps from the record — what the estate does that no board carries

The record census (nx_goalmap record) reads the invoked-tool population and every plan queue row and files each organ or directive that NO matrix, plan or gates row names. A row here is a callout the boards missed: adjudicate it onto a board or declare it infrastructure. Census state STALE (age 1395902 s), sources read 4 of 7 declared — a BLIND census is a FLOOR: unread sources can only add rows.

kind	name	board	source	evidence

rows shown 0|this board's directives 0|estate-wide un-boarded organs 452 (listed in full on /compare/ecosystem)|census rows 639|malformed 0 (counted, never rendered)

References

Beyond a link list. Every reference below resolves twice — the publisher's copy and, where banked, the estate's own non-rottable library mirror with a content pin — and carries its evidence class plus the exact claim on this page it grounds. Keyed marks like [key] in the matrix notes jump here. A dash means honestly absent, never assumed.

[wolfram] Wolfram Language reference entry for Integrate (reference.wolfram.com, read 2026-08-28). The vendor's own function page, carrying worked examples including a definite integral of x to the n over zero to one and the same integral re-evaluated under Assumptions n greater than zero, showing assumption-directed symbolic integration as a first-class documented feature. publisher · read in our library knowledge/fetched/cmp_computational_wolfram.html · pin h04fbab01d63faf1ed848e7d674623f0e62c79c108d35893a2aa4f59ca3a9cc2f · accessed 2026-08-28 · vendor-docGrounds: The Wolfram column on the symbolic-integration row and the depth claim its note makes, that Wolfram Risch-plus is far deeper than our nx_calc_integrate.
[sympy] SymPy documentation, Integrals module (docs.sympy.org latest, read 2026-08-28). The library's own API reference, including the integral transforms it ships -- for example mellin_transform, which returns the transform together with its fundamental strip and auxiliary convergence conditions, and returns an unevaluated MellinTransform object when no closed form exists. publisher · read in our library knowledge/fetched/cmp_computational_sympy.html · pin h677f463e032b302b8bced2d3ed69abbf6c559fa2df098fa5b9b52e4e40ccfa0d · accessed 2026-08-28 · vendor-docGrounds: The SymPy column on the symbolic-integration and series-expansion rows: an engine that returns a named unevaluated object rather than a wrong answer is the behaviour our own adaptive-quadrature contract is written against.
[sage] SageMath Reference Manual version 10.8, Symbolic Calculus section index (doc.sagemath.org, read 2026-08-28). The project's own reference index for its symbolic calculus surface. publisher · read in our library knowledge/fetched/cmp_computational_sage.html · pin h250922bcbd195958cff3f603a74ae9e2f8d8b093043e04004cac517951b2b9b8 · accessed 2026-08-28 · vendor-docGrounds: The SageMath column on the equation-solving row, whose note names Wolfram and Sage as the two that solve general systems.
[maxima] Maxima documentation index (maxima.sourceforge.io, read 2026-08-28). The project's own documentation landing page for the Maxima computer algebra system, the entry point to its reference manual and add-on packages. publisher · read in our library knowledge/fetched/cmp_computational_maxima.html · pin ha309ea6ddf56fab16e80c1b690b2f9d0c518ded8237606b1411edceedd7d688b · accessed 2026-08-28 · vendor-docGrounds: The Maxima column across the board and specifically the probability row, whose note credits Maxima only via its distrib add-on package rather than the core.

generated by nx_swcompare_matrix (sovereign NishiLang organ) from knowledge/compare/computational.matrix · source checks show implementation presence; runtime and user-outcome evidence are reported separately · JavaScript supports page controls