The Ontology
The ontology is a queryable canon of software architecture. It holds every principle with its relations and its repair, every term with its definition, every algorithm with its contract, the reasoning that derives them, the layers they live in and how every tension between them is resolved, and every reference from one record to another is a link.
Reasoning
The derivation loop
Every algorithm grammar is an instance of the derivation loop, which has ten stages, each on one reasoning axis, joined by transitions that sequence, gate or refute back. Each stage is listed with the contracts that run at it and the records it grounds, and the traversal is taught in the loop on the methodology page.
The substrate
Beneath the loop lies the generative substrate, meaning the cycle every node passes through, the recursion that turns emergence back into a new difference, and the math types each node yields.
The reasoning layers
The reasoning axes are arranged on these layers, each listed with the question it answers and the axes it holds.
The axes
Each reasoning axis is a typed, terminating question on one layer, listed with the nodes a run may select on it and the contracts positioned on it.
The nodes
Every node on the axes is listed with the concept it resolves to, the question it asks, the math type it yields, the shape of its answer, its decision test and its role, and the surfaces and contracts that ground themselves in it.
The mathematics
The predicates are typed by these math types, each listed with its contracts and the domains of mathematics it draws on.
The dimensions
The ontological dimensions are what can be observed about a subject, and each is listed with the test surfaces that observe it.
The lenses
The analysis lenses are how a subject is seen. Each sits on one universal axis and is listed with the fields of mathematics it draws on, the surfaces and detectors it feeds and the test surfaces that see through it.
The modes
Each reasoning mode is listed with the practice it names and the techniques that work in it.
The representations
A result can be encoded in any of these representation layers.
The pattern types
Each pattern type is listed with the mathematical viewpoint it takes.
The models
The models are sequences that restate the same cycle from different starting points.
The universal axes
The five universal axes are listed with the dimensions each one subsumes and the lenses that sit on it.
The test surfaces
The test surfaces are what a system can be wrong about. Each is a dimension seen through a lens, listed with the invariant that must hold, the techniques that observe it, the predicate and what grounds it, the evidence it requires and the verdicts it can return. The architecture page reads the same grid in what can drift, seen through how it drifts.
The techniques
Each technique a surface is observed by works in one reasoning mode and is listed with the surfaces that use it.
The invariants
Each invariant the test surfaces assert is listed with the surfaces that assert it.
Failure shapes
Each failure shape names a way a check goes wrong without failing, the invariant it breaks, its fix, the records it shows up in and the quality rules that refuse it.
The uncovered cells
These cells of the dimension and lens grid are not yet covered by any surface. The list is derived from the grid and the surfaces, never stored.
The maps
The reasoning collection carries these maps beside its records, namely the foundation sequence with the math types on each of its layers, the invariant groups, and the operations a pattern admits.
The groundings
Every grounding edge the reasoning collection declares is listed with the record it leaves from and the record or grammar it lands on, or with the label it carries where it names a rule rather than a record.