The Ontology

A canon of software architecture you can query: 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 the resolution of every tension between them. Every reference one record makes to another is a link, so any record is a starting point.

Reasoning

559 of 559 shown

The derivation loop

The derivation loop every algorithm grammar is an instance of: ten stages, each on one reasoning axis, joined by transitions that either sequence, gate or refute back. Each stage names the contracts that run at it and the records it grounds.

Relations diagram
The derivation loop with its gates.
flowchart TB
    n_orient["orient · ontology"]
    n_intent["intent · teleology"]
    n_see["see · analysis"]
    n_derive["derive · reasoning"]
    n_project["project · reasoning"]
    n_act["act · formalisation"]
    n_constrain["constrain · teleology"]
    n_verify["verify · verification"]
    n_commit["commit · representation"]
    n_terminate["terminate · termination"]
    n_orient --> n_intent
    n_intent -- tel-priority --> n_see
    n_see --> n_derive
    n_derive --> n_project
    n_project --> n_act
    n_act --> n_constrain
    n_constrain --> n_verify
    n_verify -.-> n_derive
    n_verify --> n_commit
    n_commit --> n_terminate
    n_terminate --> n_orient

orient

Details

see

Details

derive

Details

project

Details

act

Details
Contracts
Portable Contract Composition, Adapter Rendering, File Modification Recovery, Shared Document Workspace, Agent Document Responsibility, Agent Activation Invocation, Parallel Batch Execution, Sequential Agent Execution, Handoff Signal, Orchestrator Action, Workflow Coordination Sequence, Workflow Recovery Loop, Checklist Integration, Phase Documentation Template, Capability Invocation Protocol, Centralized Reference Resolver, Cache Invalidation Strategy, Manual Fallback Preservation, Dynamic Failure Isolation, Entry Point Migration, Knowledge Capture, Replacement Refactor, Rollback-Centered Execution, Compilation Stage, Codebase Pattern Enforcement, Verb Template Binding, Task Atomization, Ripple Chain Analysis, Validator Coverage, Structured Observability Context, Cross-Cutting Surface Coverage, Legacy Elimination, Hierarchical Numbering, File-Scoped Fix, File Limit Remediation, Import Boundary Remediation, Naming Convention Remediation, Base-Class Compliance Remediation, CSS Token Remediation, DOM Factory Remediation, Console Usage Remediation, Lifecycle Symmetry Remediation, Stylelint Post-Fix, File Modification Recovery, Defensive String Normalization, Safe Arithmetic Contract, Recursion Control, Advanced Tool Escalation, Idempotent Merge, Deterministic Merge Core, Persistence Fork, Composed Turn Contract, PAG Control-Flow Determinism, PAG Tool Invocation, Base Schematic Composition, Backup-Verified Migration, Registry Regeneration, Anti-Reintroduction Gate, Comment Normalization Remediation, Custom-Rule Derivation, Container Reshape, Test Authoring

verify

Details

orient → intent

Details

orientintent · Transition: sequences

intent → see

Details

intentsee · Transition: gates · Gate: tel-priority · On fail: redirect

see → derive

Details

seederive · Transition: sequences

derive → project

Details

deriveproject · Transition: sequences

project → act

Details

projectact · Transition: sequences

act → constrain

Details

actconstrain · Transition: sequences

verify → derive

Details

verifyderive · Transition: refutes-back · Gate: ver-evidence · On fail: derive

verify → commit

Details

verifycommit · Transition: sequences

terminate → orient

Details

terminateorient · Transition: sequences · Gate: ter-stop · On pass: stop

The substrate

The generative substrate beneath the loop: the cycle every node passes through, the recursion that turns emergence back into a new difference, and the math types each node yields.

Recursion · emergencedifference

Relations diagram
The substrate cycle and its recursion.
flowchart LR
    n_existence["existence"]
    n_difference["difference"]
    n_relation["relation"]
    n_structure["structure"]
    n_transformation["transformation"]
    n_constraint["constraint"]
    n_emergence["emergence"]
    n_existence --> n_difference
    n_difference --> n_relation
    n_relation --> n_structure
    n_structure --> n_transformation
    n_transformation --> n_constraint
    n_constraint --> n_emergence
    n_emergence -.-> n_difference

The reasoning layers

The layers the reasoning axes are arranged on, each with the question it answers and the axes it holds.

Substrate

Details
Question
How does anything come to be?

Conative

Details
Question
What is worth doing?

The axes

The reasoning axes, each a typed terminating question on one layer, with the nodes a run may select on it and the contracts positioned on it.

ontology

Details

analysis

  • Layer: epistemic
  • Mandatory: when-relevant
  • Math type: graph
  • Selectable: yes
Details

reasoning

  • Layer: epistemic
  • Mandatory: when-relevant
  • Math type: logic
  • Selectable: yes
Details

representation

Details

formalisation

Details
Question
What does it resolve to?
Contracts
Portable Contract Composition, Adapter Rendering, File Modification Recovery, Shared Document Workspace, Agent Document Responsibility, Agent Activation Invocation, Parallel Batch Execution, Sequential Agent Execution, Handoff Signal, Orchestrator Action, Workflow Coordination Sequence, Workflow Recovery Loop, Checklist Integration, Phase Documentation Template, Capability Invocation Protocol, Centralized Reference Resolver, Cache Invalidation Strategy, Manual Fallback Preservation, Dynamic Failure Isolation, Entry Point Migration, Knowledge Capture, Replacement Refactor, Rollback-Centered Execution, Compilation Stage, Codebase Pattern Enforcement, Verb Template Binding, Task Atomization, Ripple Chain Analysis, Validator Coverage, Structured Observability Context, Cross-Cutting Surface Coverage, Legacy Elimination, Hierarchical Numbering, File-Scoped Fix, File Limit Remediation, Import Boundary Remediation, Naming Convention Remediation, Base-Class Compliance Remediation, CSS Token Remediation, DOM Factory Remediation, Console Usage Remediation, Lifecycle Symmetry Remediation, Stylelint Post-Fix, File Modification Recovery, Defensive String Normalization, Safe Arithmetic Contract, Recursion Control, Advanced Tool Escalation, Idempotent Merge, Deterministic Merge Core, Persistence Fork, Composed Turn Contract, PAG Control-Flow Determinism, PAG Tool Invocation, Base Schematic Composition, Backup-Verified Migration, Registry Regeneration, Anti-Reintroduction Gate, Comment Normalization Remediation, Custom-Rule Derivation, Container Reshape, Test Authoring

teleology

Details

verification

Details

termination

Details

The nodes

Every node on the axes: 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.

for-relation

Details
Question
What mapping connects objects?

tel-utility

Details
Question
How much does this advance the objective?
Answer shape
number

tel-priority

Details
Question
Is this the highest-worth admissible branch?
Answer shape
boolean
Decision test
highest utility minus cost among admissible branches
Role
injection-gate

ver-evidence

Details

ver-ground-truth

Details

ver-falsification

Details
Question
What would refute it?

ver-confidence

Details
Question
How confident, and is it enough?
Answer shape
number[0,1]
Decision test
confidence at or above threshold

ver-refutation

Details
Question
Does refutation outweigh support?

ter-completion

Details
Question
Is every task done?
Answer shape
boolean
Decision test
every task is done
Role
completion-marker

ter-saturation

Details
Question
Is nothing left to resolve?
Answer shape
boolean
Decision test
no open items remain
Role
both

ter-diminishing-returns

Details
Question
Has progress stopped increasing?
Answer shape
counter
Decision test
progress unchanged across a bounded window
Role
injection-gate

ter-block

Details
Question
Is it blocked on external input?
Answer shape
boolean

The mathematics

The math types the predicates are typed by, with the contracts of each type, and the domains of mathematics they draw on.

set-theory

Details

logic

Details
Question
Does it hold; what follows?
Predicate family
boolean predicate
Yields shape
boolean
Contracts
Semantic Operation Boundary, Domain Cache Validation, Principle Extraction, Phase Validation Requirement, Validation Strategy Composition, Semantic Compliance Validation, Algorithmic Embodiment Validation, Agent Generation Completion, Hybrid Workflow Orchestration, Context Forking Configuration, Verb-Based Execution Classification, Workflow Type Document Selection, Handoff Signal, Orchestrator Action, Workflow Principles Mapping, Workflow Validation Gate, Anti-Pattern Inversion, Architecture Smell Record, Architectural Force Classification, Conflict and Tension Resolution, Violation Detection, Enforcement Gate, Modular Boundary Compliance, Contract Compatibility, Domain Boundary Governance, Runtime Extensibility, Event and Messaging Consistency, State and Transaction Safety, Correctness Verification, Resilience Policy, Security Governance, Control Plane Coordination, Metaprogramming Safety, AI Model Architecture Governance, Relationship Schema Validation, Constraints Over Shortcuts, Forward Compatibility Over Backward Compatibility, Fail-Fast Over Fallback, Explicit Removal Over Deprecation, Greenfield Over Legacy, Single-Path Determinism Over Dual-Path, Immediacy Over Deferring, Mandatory Over Optional, Now Over For-Now, Observed Execution Over Unobserved, Compression Over Repetition, Approved Evolution Over Unapproved, Enforced Feedback Over Ignored, Single Owner Over Shared Ownership, Bounded Lifetime Over Unbounded, Enforced Symmetry Over Asymmetric Lifecycle, Explicit Retention Over Implicit, Structural Release Over Discipline, Immutable Data Over Mutable State, Errors As Language Over Silent Errors, Explicit Invalidity Over Hidden, Event Emission Over Parent Callbacks, Monotonic Growth Over Retraction, Semantic Addressing Over Location Addressing, Ordinal Time Over Timestamps, Homoiconicity Over Separation, Bounded Complexity Over Unlimited, Computed Health Over Metric Health, Secret Store Over Hardcoded Secrets, Boundary Validation Over Unvalidated Input, Least Privilege Over Broad Privilege, Config Externalization Over Env Fallback, Profile-First Over Unmeasured Optimization, Rule As Code Over Convention, Design By Contract Over Implicit Contract, Versioned Evolution Over Breaking Change, Schema-Validated Boundary Over Untyped, Atomic Boundary Over Partial Commit, Saga Compensation Over Distributed 2PC, Async Events Over Synchronous Cross-Boundary, Observable Signals Over Opaque Runtime, Injected Dependency Over Hidden, Convention Discovery Over Hardcoded Wiring, Declarative Config Over Imperative, Anti-Corruption Layer Over Cross-Context Leak, Injected Nondeterminism Over Hidden, Pattern By Fit Over Speculative Pattern, Document Truth Alignment, Interface Contract, Substitutability, Extension Point, Behavioral Dispatch, Port Adapter, Transaction Boundary, Idempotent Side Effect, Deterministic Core, Error Boundary, Cache Correctness, Security Policy, Control Plane, AI Model Governance, Universal Architectural Concern Template, Consumer Config SSOT, Runtime-Neutral Automation Boundary, Intentional Static Separation, Extension Interface Discovery, Performance-Aware Discovery Design, Dynamic Extension Architecture, Cache Invalidation Strategy, Dynamic Failure Isolation, Measured-vs-Estimated Validation, Architecture Validation Before Persistence, Automation Completion Status, Runtime-Agnostic Adapter Boundary, Pattern Classification, Refactor Intent Classification, Architecture Compliance Targeting, Existing Solution Conflict, Additive Debt Gate, Pattern-Specific Validation, Zero-Duplication Verification, Completion Truthfulness, Trust Anchor, Intent & Directionality Normalization, Planning Stage, Principle Activation, Protocol Semantic Selection, Loop Class Labeling, Codebase Pattern Enforcement, Validator Coverage, Structured Observability Context, Cross-Cutting Surface Coverage, Legacy Elimination, Validation Stage, Semantic Debt Policy, Evidence-Based Claim Verification, Validation Suite Battery, Verification Execution, Violation Classification, Reverification Gate, Evidence-Gated Claim Verification, Environment Capability Verification, Behavioral Self-Test, Adversarial Input Testing, Safe Arithmetic Contract, Type-Keyed Appearance, Plan Phase Verification, Delta Capture, Mode Contract Validation, PAG Validation Gate, PAG Control-Flow Determinism, PAG Ambiguity Reduction, PAG Well-Formedness Validation, Anti-Pattern Classification, Abstraction Boundary Principle, Base-Class Candidate Selection, Anti-Pattern Elimination Verification, Completion Truthfulness, Canonical Config Resolution, Machine Verdict Derivation, Concern Classification, Discovery Verification, Taxonomy Completion, Uncovered Gap Derivation, Evidence Verdict, Coverage Completion

graph

  • Domain: Graphs / Category theory
Details

algebra

Details

optimisation

  • Domain: Axioms / Optimisation
Details

information-theory

Details

computation

Details
Question
What can be generated or solved?
Predicate family
algorithm / loop
Yields shape
procedure
Contracts
Portable Contract Composition, Adapter Rendering, Agent Creator Kernel, File Modification Recovery, Shared Document Workspace, Agent Document Responsibility, Agent Activation Invocation, Parallel Batch Execution, Sequential Agent Execution, Workflow Coordination Sequence, Checklist Integration, Phase Documentation Template, Capability Invocation Protocol, Workflow Creation Kernel, Anti-Pattern Rule Compiler, Architecture Fitness Function Generation, Architecture Catalog Compiler, Master Architecture Governance Kernel, Architectural Contract Kernel, Construction Boundary, Saga Compensation, Declarative Metaprogramming, Manifest-Driven Documentation, Centralized Reference Resolver, Manual Fallback Preservation, Entry Point Migration, Knowledge Capture, Automation Kernel, Replacement Refactor, Rollback-Centered Execution, Centralization Kernel, Dynamic Discovery Pattern Generation, Compilation Stage, Verb Template Binding, Task Atomization, Checklist Creation Kernel, File-Scoped Fix, File Limit Remediation, Import Boundary Remediation, Naming Convention Remediation, Base-Class Compliance Remediation, CSS Token Remediation, DOM Factory Remediation, Console Usage Remediation, Lifecycle Symmetry Remediation, Stylelint Post-Fix, Codebase Verification Kernel, File Modification Recovery, Defensive String Normalization, Advanced Tool Escalation, Contract-Based Verification Kernel, Governed Construction Boundary, Type-Migration Centralization, Governed Autonomous Plan Loop, Idempotent Merge, Deterministic Merge Core, Persistence Fork, Living Profile Kernel, Composed Turn Contract, Loop-Owned Mode Selection, PAG Tool Invocation, PAG Authoring Kernel, Base Schematic Composition, Backup-Verified Migration, Registry Regeneration, Anti-Reintroduction Gate, Pattern Distiller Kernel, Quality Governance Loop, Comment Normalization Remediation, Custom-Rule Derivation, Container Reshape, Taxonomy Kernel, Test Authoring, Test Coverage Kernel

number

Details
Studies
quantity
Question
What can be counted or measured?

algebra

Details
Studies
operations and structures
Question
What rules govern transformations?

geometry

Details
Studies
space and form
Question
What shapes and spaces exist?

topology

Details
Studies
continuity and connectivity
Question
What remains invariant under deformation?

analysis

Details
Studies
change and limits
Question
How do quantities vary?

logic

Details
Studies
truth and inference
Question
What statements follow from others?

set-theory

Details
Studies
collection and membership
Question
What objects can be constructed?

combinatorics

Details
Studies
discrete arrangements
Question
How many configurations exist?

probability

Details
Studies
uncertainty
Question
What outcomes are possible and likely?

information-theory

Details
Studies
information and compression
Question
What patterns can be encoded?

computation

Details
Studies
procedures and algorithms
Question
What can be generated or solved?

category-theory

Details
Studies
relationships between structures
Question
How do mathematical worlds connect?

The dimensions

The ontological dimensions: what can be observed about a subject, each with the test surfaces that observe it.

space

  • Nature: geometry
Details
Question
Where is it?

change

  • Nature: operation
Details
Question
How does it transform?

The lenses

The analysis lenses: how a subject is seen, each on one universal axis, with the fields of mathematics it draws on, the surfaces and detectors it feeds and the test surfaces that see through it.

spatial

Details
Question
How is it distributed in space?
Surfaces
none
Detectors
none

functional

Details
Question
What role does something perform?
Fields
functional-analysis
Surfaces
none
Detectors
none

predictive

Details
Question
What usually follows?
Fields
applied-mathematics
Surfaces
none
Detectors
none

fractal

Details
Question
Does the same structure recur at different scales?
Fields
fractal-geometry, renormalisation
Surfaces
scale_duplication

transformational

  • Nature: transformation
  • Universal axis: dynamics
Details
Question
How does one state become another?
Surfaces
none
Detectors
none

invariant

Details
Question
What remains unchanged?
Fields
symmetry, topology
Surfaces
none
Detectors
none

optimisation

Details
Question
What is the best possible state?
Fields
operations-research
Surfaces
none
Detectors
none

complexity

Details
Question
How difficult is the transformation?
Fields
computation-theory
Surfaces
none
Detectors
none

The modes

The reasoning modes, the practice each one names and the techniques that work in it.

description

Details
Mode
define objects
Question
How can it be characterised?
Techniques

abstraction

Details
Mode
remove irrelevant details

generalisation

Details
Mode
extend examples into principles

formalisation

Details
Mode
express ideas symbolically

explanation

Details
Mode
identify mechanisms
Question
Why is it this way?
Techniques

deduction

Details
Mode
derive necessary consequences

construction

Details
Mode
build objects satisfying rules

proof

Details
Mode
establish certainty

optimisation

Details
Mode
select preferred solutions

creation

Details
Mode
generate new structures
Question
Can new examples be produced?
Techniques

reflection

Details
Mode
discover deeper principles
Question
What general principles emerge?

The representations

The representation layers a result can be encoded in.

symbolic

Details

equations, formulas, notation

logical

Details

statements, predicates, proofs

numerical

Details

numbers, quantities, measurements

algebraic

Details

operations, groups, fields

geometric

Details

shapes, coordinates, spaces

topological

Details

connectivity, continuity

graphical

Details

diagrams, graphs, networks

matrix

Details

linear transformations

functional

Details

mappings between spaces

information-theoretic

Details

entropy, encoding, compression

probabilistic

Details

distributions and likelihoods

dynamical

Details

state transitions

computational

Details

algorithms and programs

categorical

Details

objects and morphisms

The pattern types

The pattern types and the mathematical viewpoint each one takes.

symbolic

Details

formal systems and equations

numerical

Details

quantity and arithmetic

algebraic

Details

operations and transformations

geometric

Details

shape and space

topological

Details

connectivity and invariance

logical

Details

truth and implication

combinatorial

Details

arrangement possibilities

statistical

Details

distribution and variation

probabilistic

Details

randomness and uncertainty

information

Details

compression and complexity

dynamical

Details

change over time

computational

Details

procedures and algorithms

categorical

Details

relationships between structures

fractal

Details

recursive self-similarity

The models

The models: the sequences that restate the same cycle from different starting points.

pattern-cycle

  • Question: How does pattern-work proceed?
  • Recursion: create → exist
Details
Sequence
exist → differentiate → relate → organise → transform → constrain → stabilise → represent → reason → predict → create

The universal axes

The five universal axes, the dimensions each one subsumes and the lenses that sit on it.

existence

Details
Question
What entities are present?
Subsumes

The test surfaces

The test surfaces: what a system can be wrong about, each a dimension seen through a lens, 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 techniques

The techniques a surface is observed by, each in one reasoning mode, with the surfaces that use it.

The invariants

The invariants the test surfaces assert, each with the surfaces that assert it.

valid-state-transitions

Details
Invariant
Valid state transitions

valid-interfaces-and-contracts

Details
Invariant
Valid interfaces and contracts

acceptable-resource-consumption

Details
Invariant
Acceptable resource consumption

deterministic-behaviour-where-required

Details
Invariant
Deterministic behaviour where required

The uncovered cells

The cells of the dimension and lens grid that no surface covers yet. The list is derived from the grid and the surfaces, never stored.

The maps

The maps the reasoning face carries beside its records: the foundation sequence and the math types on each of its layers, the invariant groups, and the operations a pattern admits.

Foundation sequence

Details

logic-set-theory-axioms → structurechange → relationships → possibility → application

generative

Details

objects, relations, transformations, constraints, emergence

The groundings

Every grounding edge the reasoning face declares: the record an edge leaves from, the record or grammar it lands on, or the label it carries where it names a rule rather than a record.

ver-evidence

Details

ver-evidence → Carries: claims-are-lies