{
  "content": {
    "icon": "bi-compass",
    "id": "reasoning",
    "label": "Reasoning",
    "layout": "ontology",
    "sections": [
      {
        "blocks": [
          {
            "caption": "The derivation loop with its gates.",
            "kind": "mermaid",
            "text": "flowchart TB\n    n_orient[\"orient · ontology\"]\n    n_intent[\"intent · teleology\"]\n    n_see[\"see · analysis\"]\n    n_derive[\"derive · reasoning\"]\n    n_project[\"project · reasoning\"]\n    n_act[\"act · formalization\"]\n    n_constrain[\"constrain · teleology\"]\n    n_verify[\"verify · verification\"]\n    n_commit[\"commit · representation\"]\n    n_terminate[\"terminate · termination\"]\n    n_orient --> n_intent\n    n_intent -- tel-priority --> n_see\n    n_see --> n_derive\n    n_derive --> n_project\n    n_project --> n_act\n    n_act --> n_constrain\n    n_constrain --> n_verify\n    n_verify -.-> n_derive\n    n_verify --> n_commit\n    n_commit --> n_terminate\n    n_terminate --> n_orient"
          },
          {
            "kind": "text",
            "text": "How it is checked"
          },
          {
            "entries": [
              {
                "description": "the reasoning-native check, which requires every process grammar's kernel to map the loop's stages and every staged record to name a real stage and that stage's axis",
                "term": "Checked by"
              },
              {
                "description": "Every process grammar, its kernel and its staged records",
                "term": "Population"
              },
              {
                "description": "A verdict stands until the loop, a grammar or a staged record changes",
                "term": "Freshness"
              },
              {
                "description": "The gate fails on an unknown stage, a stage whose axis does not match, or a kernel that omits the verify stage",
                "term": "Refusal"
              },
              {
                "description": "None, because the loop is a procedure the grammars instantiate, and nothing observes it while a run executes",
                "term": "Observation"
              },
              {
                "description": "Watched to fire and to accept: a suite plants an unknown stage, a mismatched axis and a kernel that omits the verify stage, and passes a fully typed staged record",
                "term": "Evidence"
              },
              {
                "description": "The loop's stage list, which every kernel and staged record cites",
                "term": "Authoritative side"
              },
              {
                "description": "Not answered",
                "term": "Depends on"
              },
              {
                "description": "Not answered",
                "term": "Shape it refuses"
              }
            ],
            "kind": "glossary"
          }
        ],
        "icon": "bi-signpost-split",
        "id": "reasoning-loop-derivation-loop",
        "intro": "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](/disciplined-methodology#the-loop) on the methodology page.",
        "subsections": [
          {
            "blocks": [
              {
                "items": [
                  "Axis: [ontology](/records/reasoning/axis-ontology)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "[Evidence-Before-Generation](/records/algorithms/evidence-before-generation), [Semantic Operation Boundary](/records/algorithms/semantic-operation-boundary), [Capability Profile](/records/algorithms/capability-profile), [Domain Cache Validation](/records/algorithms/domain-cache-validation), [Scope Extraction](/records/algorithms/scope-extraction), [Domain Knowledge Base](/records/algorithms/domain-knowledge-base), [DSL Compliance Loading](/records/algorithms/dsl-compliance-loading), [Workspace Configuration Discovery](/records/algorithms/workspace-configuration-discovery), [Runtime-Neutral Automation Boundary](/records/algorithms/runtime-neutral-automation-boundary), [Capability Degradation](/records/algorithms/capability-degradation), [Automation Opportunity Detection](/records/algorithms/automation-opportunity-detection), [Runtime-Agnostic Adapter Boundary](/records/algorithms/runtime-agnostic-adapter-boundary), [Capability Disclosure](/records/algorithms/capability-disclosure), [Iterative Variation Discovery](/records/algorithms/iterative-variation-discovery), [Detection Registry](/records/algorithms/detection-registry), [Orientation Stage](/records/algorithms/orientation-stage), [Authoritative Source Loading](/records/algorithms/authoritative-source-loading), [Trust Anchor](/records/algorithms/trust-anchor), [Intent & Directionality Normalization](/records/algorithms/intent-directionality-normalization), [Skeptical Context Acquisition](/records/algorithms/skeptical-context-acquisition), [Dynamic Discovery Pattern Generation](/records/algorithms/dynamic-discovery-pattern-generation), [Context Initialization](/records/algorithms/context-initialization), [Trust Anchor Declaration](/records/algorithms/trust-anchor-declaration), [Coverage Workspace](/records/algorithms/coverage-workspace), [PAG Document Declaration](/records/algorithms/pag-document-declaration), [Analysis Workspace](/records/algorithms/analysis-workspace), [Registry Baseline](/records/algorithms/registry-baseline), [Profile Compose](/records/algorithms/profile-compose), [Seed Composition](/records/algorithms/seed-composition), [Taxonomy Jurisdiction](/records/algorithms/taxonomy-jurisdiction)",
                    "term": "Contracts"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the reasoning-native check, which requires every process grammar's kernel to map the loop's stages and every staged record to name a real stage and that stage's axis",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every process grammar, its kernel and its staged records",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the loop, a grammar or a staged record changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on an unknown stage, a stage whose axis does not match, or a kernel that omits the verify stage",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because the loop is a procedure the grammars instantiate, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants an unknown stage, a mismatched axis and a kernel that omits the verify stage, and passes a fully typed staged record",
                    "term": "Evidence"
                  },
                  {
                    "description": "The loop's stage list, which every kernel and staged record cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "stage-orient",
            "title": "orient"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [teleology](/records/reasoning/axis-teleology)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "[Adaptive Phase Boundary](/records/algorithms/adaptive-phase-boundary), [Static-to-Dynamic Readiness](/records/algorithms/static-to-dynamic-readiness), [Automation Priority Ordering](/records/algorithms/automation-priority-ordering), [Canonical Variation Selection](/records/algorithms/canonical-variation-selection), [Developer Decision Gate](/records/algorithms/developer-decision-gate), [Teleological Intent Gate](/records/algorithms/teleological-intent-gate), [Severity-Ordered Remediation](/records/algorithms/severity-ordered-remediation), [Coverage Risk Prioritization](/records/algorithms/coverage-risk-prioritization), [Anti-Pattern Priority Matrix](/records/algorithms/anti-pattern-priority-matrix), [Reshape Risk Priority](/records/algorithms/reshape-risk-priority)",
                    "term": "Contracts"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the reasoning-native check, which requires every process grammar's kernel to map the loop's stages and every staged record to name a real stage and that stage's axis",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every process grammar, its kernel and its staged records",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the loop, a grammar or a staged record changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on an unknown stage, a stage whose axis does not match, or a kernel that omits the verify stage",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because the loop is a procedure the grammars instantiate, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants an unknown stage, a mismatched axis and a kernel that omits the verify stage, and passes a fully typed staged record",
                    "term": "Evidence"
                  },
                  {
                    "description": "The loop's stage list, which every kernel and staged record cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "stage-intent",
            "title": "intent"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [analysis](/records/reasoning/axis-analysis)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "[Non-Destructive Domain Investigation](/records/algorithms/non-destructive-domain-investigation), [Risk Complexity Reversibility](/records/algorithms/risk-complexity-reversibility), [Existing Pattern Extraction](/records/algorithms/existing-pattern-extraction), [Knowledge Documentation Relevance](/records/algorithms/knowledge-documentation-relevance), [Breaking Point Calculation](/records/algorithms/breaking-point-calculation), [Convention Strength Analysis](/records/algorithms/convention-strength-analysis), [Scalability Projection](/records/algorithms/scalability-projection), [Research Guidance](/records/algorithms/research-guidance), [Tool Calibration](/records/algorithms/tool-calibration), [Lifetime Resolution](/records/algorithms/lifetime-resolution), [Surface Grid Walk](/records/algorithms/surface-grid-walk), [PAG Keyword Ontology](/records/algorithms/pag-keyword-ontology), [Compliance Gap](/records/algorithms/compliance-gap), [Semantic Domain Partitioning](/records/algorithms/semantic-domain-partitioning), [Behavioral Signature Extraction](/records/algorithms/behavioral-signature-extraction), [Cross-Class Pattern Detection](/records/algorithms/cross-class-pattern-detection), [Behavioral Inconsistency](/records/algorithms/behavioral-inconsistency), [Sequential Chain Duplication](/records/algorithms/sequential-chain-duplication), [Temporal Coupling Detection](/records/algorithms/temporal-coupling-detection), [Relational Graph Duplication](/records/algorithms/relational-graph-duplication), [Causal Wiring Duplication](/records/algorithms/causal-wiring-duplication), [Anomaly Outlier Detection](/records/algorithms/anomaly-outlier-detection), [Conceptual Duplication Detection](/records/algorithms/conceptual-duplication-detection), [Fractal Scale Duplication](/records/algorithms/fractal-scale-duplication), [Path Role Walk](/records/algorithms/path-role-walk)",
                    "term": "Contracts"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the reasoning-native check, which requires every process grammar's kernel to map the loop's stages and every staged record to name a real stage and that stage's axis",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every process grammar, its kernel and its staged records",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the loop, a grammar or a staged record changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on an unknown stage, a stage whose axis does not match, or a kernel that omits the verify stage",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because the loop is a procedure the grammars instantiate, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants an unknown stage, a mismatched axis and a kernel that omits the verify stage, and passes a fully typed staged record",
                    "term": "Evidence"
                  },
                  {
                    "description": "The loop's stage list, which every kernel and staged record cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "stage-see",
            "title": "see"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [reasoning](/records/reasoning/axis-reasoning)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "[Principle Extraction](/records/algorithms/principle-extraction), [Hybrid Workflow Orchestration](/records/algorithms/hybrid-workflow-orchestration), [Context Forking Configuration](/records/algorithms/context-forking-configuration), [Verb-Based Execution Classification](/records/algorithms/verb-based-execution-classification), [Workflow Type Document Selection](/records/algorithms/workflow-type-document-selection), [Workflow Principles Mapping](/records/algorithms/workflow-principles-mapping), [Intentional Static Separation](/records/algorithms/intentional-static-separation), [Extension Interface Discovery](/records/algorithms/extension-interface-discovery), [Pattern Classification](/records/algorithms/pattern-classification), [Refactor Intent Classification](/records/algorithms/refactor-intent-classification), [Architecture Compliance Targeting](/records/algorithms/architecture-compliance-targeting), [Existing Solution Conflict](/records/algorithms/existing-solution-conflict), [Planning Stage](/records/algorithms/planning-stage), [Principle Activation](/records/algorithms/principle-activation), [Protocol Semantic Selection](/records/algorithms/protocol-semantic-selection), [Violation Classification](/records/algorithms/violation-classification), [Invocation Join](/records/algorithms/invocation-join), [Duplicate Disposition Walk](/records/algorithms/duplicate-disposition-walk), [Uncovered Gap Derivation](/records/algorithms/uncovered-gap-derivation), [PAG Ambiguity Reduction](/records/algorithms/pag-ambiguity-reduction), [Anti-Pattern Classification](/records/algorithms/anti-pattern-classification), [Abstraction Boundary Principle](/records/algorithms/abstraction-boundary-principle), [Base-Class Candidate Selection](/records/algorithms/base-class-candidate-selection), [Canonical Config Resolution](/records/algorithms/canonical-config-resolution), [Concern Classification](/records/algorithms/concern-classification), [Container Ladder](/records/algorithms/container-ladder), [Export Triage Ladder](/records/algorithms/export-triage-ladder)",
                    "term": "Contracts"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the reasoning-native check, which requires every process grammar's kernel to map the loop's stages and every staged record to name a real stage and that stage's axis",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every process grammar, its kernel and its staged records",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the loop, a grammar or a staged record changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on an unknown stage, a stage whose axis does not match, or a kernel that omits the verify stage",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because the loop is a procedure the grammars instantiate, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants an unknown stage, a mismatched axis and a kernel that omits the verify stage, and passes a fully typed staged record",
                    "term": "Evidence"
                  },
                  {
                    "description": "The loop's stage list, which every kernel and staged record cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "stage-derive",
            "title": "derive"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [reasoning](/records/reasoning/axis-reasoning)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "[Phase Validation Requirement](/records/algorithms/phase-validation-requirement), [Validation Strategy Composition](/records/algorithms/validation-strategy-composition), [Agent Sequence Definition](/records/algorithms/agent-sequence-definition), [Four-Dimensional Agent Graph](/records/algorithms/four-dimensional-agent-graph), [Performance-Aware Discovery Design](/records/algorithms/performance-aware-discovery-design), [Dynamic Extension Architecture](/records/algorithms/dynamic-extension-architecture), [Migration Action Mapping](/records/algorithms/migration-action-mapping), [Atomic Refactor Phase](/records/algorithms/atomic-refactor-phase), [Phase Decomposition](/records/algorithms/phase-decomposition), [Four-Dimensional Phase Graph](/records/algorithms/four-dimensional-phase-graph), [Dependency Linearization](/records/algorithms/dependency-linearization), [Severity Assignment](/records/algorithms/severity-assignment), [Loop Class Labeling](/records/algorithms/loop-class-labeling), [Technique and Invariant Selection](/records/algorithms/technique-invariant-selection), [PAG Node Decomposition](/records/algorithms/pag-node-decomposition), [PAG Structure Declaration](/records/algorithms/pag-coordination-construct), [Concrete-vs-Abstract Responsibility Split](/records/algorithms/concrete-vs-abstract-responsibility-split), [Template Method Lifecycle](/records/algorithms/template-method-lifecycle), [Migration Ordering](/records/algorithms/migration-ordering), [Stage Ordering](/records/algorithms/stage-ordering), [Name Projection](/records/algorithms/name-projection), [Dialect Resolution](/records/algorithms/dialect-resolution)",
                    "term": "Contracts"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the reasoning-native check, which requires every process grammar's kernel to map the loop's stages and every staged record to name a real stage and that stage's axis",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every process grammar, its kernel and its staged records",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the loop, a grammar or a staged record changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on an unknown stage, a stage whose axis does not match, or a kernel that omits the verify stage",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because the loop is a procedure the grammars instantiate, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants an unknown stage, a mismatched axis and a kernel that omits the verify stage, and passes a fully typed staged record",
                    "term": "Evidence"
                  },
                  {
                    "description": "The loop's stage list, which every kernel and staged record cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "stage-project",
            "title": "project"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [formalization](/records/reasoning/axis-formalization)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "[Portable Contract Composition](/records/algorithms/portable-contract-composition), [Adapter Rendering](/records/algorithms/adapter-rendering), [Agent Workflow File Modification Recovery](/records/algorithms/agent-workflow-file-modification-recovery), [Shared Document Workspace](/records/algorithms/shared-document-workspace), [Agent Document Responsibility](/records/algorithms/agent-document-responsibility), [Agent Activation Invocation](/records/algorithms/agent-activation-invocation), [Parallel Batch Execution](/records/algorithms/parallel-batch-execution), [Sequential Agent Execution](/records/algorithms/sequential-agent-execution), [Handoff Signal](/records/algorithms/handoff-signal), [Orchestrator Action](/records/algorithms/orchestrator-action), [Workflow Coordination Sequence](/records/algorithms/workflow-coordination-sequence), [Workflow Recovery Loop](/records/algorithms/workflow-recovery-loop), [Checklist Integration](/records/algorithms/checklist-integration), [Phase Documentation Template](/records/algorithms/phase-documentation-template), [Capability Invocation Protocol](/records/algorithms/capability-invocation-protocol), [Centralized Reference Resolver](/records/algorithms/centralized-reference-resolver), [Cache Invalidation Strategy](/records/algorithms/cache-invalidation-strategy), [Manual Fallback Preservation](/records/algorithms/manual-fallback-preservation), [Dynamic Failure Isolation](/records/algorithms/dynamic-failure-isolation), [Entry Point Migration](/records/algorithms/entry-point-migration), [Knowledge Capture](/records/algorithms/knowledge-capture), [Replacement Refactor](/records/algorithms/replacement-refactor), [Rollback-Centered Execution](/records/algorithms/rollback-centered-execution), [Compilation Stage](/records/algorithms/compilation-stage), [Codebase Pattern Enforcement](/records/algorithms/codebase-pattern-enforcement), [Verb Template Binding](/records/algorithms/verb-template-binding), [Task Atomization](/records/algorithms/task-atomization), [Ripple Chain Analysis](/records/algorithms/ripple-chain-analysis), [Validator Coverage](/records/algorithms/validator-coverage), [Structured Observability Context](/records/algorithms/structured-observability-context), [Cross-Cutting Surface Coverage](/records/algorithms/cross-cutting-surface-coverage), [Legacy Elimination](/records/algorithms/legacy-elimination), [Hierarchical Numbering](/records/algorithms/hierarchical-numbering), [File-Scoped Fix](/records/algorithms/file-scoped-fix), [File Limit Remediation](/records/algorithms/file-limit-remediation), [Import Boundary Remediation](/records/algorithms/import-boundary-remediation), [Naming Convention Remediation](/records/algorithms/naming-convention-remediation), [Base-Class Compliance Remediation](/records/algorithms/base-class-compliance-remediation), [CSS Token Remediation](/records/algorithms/css-token-remediation), [DOM Factory Remediation](/records/algorithms/dom-factory-remediation), [Console Usage Remediation](/records/algorithms/console-usage-remediation), [Lifecycle Symmetry Remediation](/records/algorithms/lifecycle-symmetry-remediation), [Stylelint Post-Fix](/records/algorithms/stylelint-post-fix), [File Modification Recovery](/records/algorithms/file-modification-recovery), [Defensive String Normalization](/records/algorithms/defensive-string-normalization), [Safe Arithmetic Contract](/records/algorithms/safe-arithmetic-contract), [Recursion Control](/records/algorithms/recursion-control), [Advanced Tool Escalation](/records/algorithms/advanced-tool-escalation), [Test Authoring](/records/algorithms/test-authoring), [PAG Explicit Control Flow](/records/algorithms/pag-explicit-control-flow), [PAG Semantic Operation](/records/algorithms/pag-tool-invocation), [Base Schematic Composition](/records/algorithms/base-schematic-composition), [Backup-Verified Migration](/records/algorithms/backup-verified-migration), [Registry Regeneration](/records/algorithms/registry-regeneration), [Anti-Reintroduction Gate](/records/algorithms/anti-reintroduction-gate), [Idempotent Merge](/records/algorithms/idempotent-merge), [Deterministic Merge Core](/records/algorithms/deterministic-merge-core), [Persistence Fork](/records/algorithms/persistence-fork), [Comment Normalization Remediation](/records/algorithms/comment-normalization-remediation), [Custom-Rule Derivation](/records/algorithms/custom-rule-derivation), [Composed Turn Contract](/records/algorithms/composed-turn-contract), [Container Reshape](/records/algorithms/container-reshape)",
                    "term": "Contracts"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the reasoning-native check, which requires every process grammar's kernel to map the loop's stages and every staged record to name a real stage and that stage's axis",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every process grammar, its kernel and its staged records",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the loop, a grammar or a staged record changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on an unknown stage, a stage whose axis does not match, or a kernel that omits the verify stage",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because the loop is a procedure the grammars instantiate, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants an unknown stage, a mismatched axis and a kernel that omits the verify stage, and passes a fully typed staged record",
                    "term": "Evidence"
                  },
                  {
                    "description": "The loop's stage list, which every kernel and staged record cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "stage-act",
            "title": "act"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [teleology](/records/reasoning/axis-teleology)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "[Creation History Collision](/records/algorithms/creation-history-collision), [Replacement Safety](/records/algorithms/replacement-safety), [Automation Operation Mode](/records/algorithms/automation-operation-mode), [Operation Mode Gating](/records/algorithms/operation-mode-gating), [Admissibility Constraint Gate](/records/algorithms/admissibility-constraint-stage), [Phase-Separated Execution](/records/algorithms/phase-separated-execution), [PAG Invariant Record](/records/algorithms/pag-constraint-boundary), [Boundary Reconciliation](/records/algorithms/boundary-reconciliation), [Vocabulary Admission Gate](/records/algorithms/vocabulary-admission-gate)",
                    "term": "Contracts"
                  },
                  {
                    "description": "[Governed Autonomous Plan Loop](/records/algorithms/governed-autonomous-plan-loop)",
                    "term": "Grounds"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the reasoning-native check, which requires every process grammar's kernel to map the loop's stages and every staged record to name a real stage and that stage's axis",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every process grammar, its kernel and its staged records",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the loop, a grammar or a staged record changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on an unknown stage, a stage whose axis does not match, or a kernel that omits the verify stage",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because the loop is a procedure the grammars instantiate, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants an unknown stage, a mismatched axis and a kernel that omits the verify stage, and passes a fully typed staged record",
                    "term": "Evidence"
                  },
                  {
                    "description": "The loop's stage list, which every kernel and staged record cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "stage-constrain",
            "title": "constrain"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [verification](/records/reasoning/axis-verification)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "[Semantic Compliance Validation](/records/algorithms/semantic-compliance-validation), [Evidence Grounding Validation](/records/algorithms/evidence-grounding-validation), [Algorithmic Embodiment Validation](/records/algorithms/algorithmic-embodiment-validation), [Workflow Validation Gate](/records/algorithms/workflow-validation-gate), [Measured-vs-Estimated Validation](/records/algorithms/measured-vs-estimated-validation), [Architecture Validation Before Persistence](/records/algorithms/architecture-validation-before-persistence), [Additive Debt Gate](/records/algorithms/additive-debt-gate), [Pattern-Specific Validation](/records/algorithms/pattern-specific-validation), [Zero-Duplication Verification](/records/algorithms/zero-duplication-verification), [Validation Score](/records/algorithms/validation-score), [Validation Stage](/records/algorithms/validation-stage), [Semantic Debt Policy](/records/algorithms/semantic-debt-policy), [Evidence-Based Claim Verification](/records/algorithms/evidence-based-claim-verification), [Validation Suite Battery](/records/algorithms/validation-suite-battery), [Repair Stage](/records/algorithms/repair-stage), [Bounded Repair Loop](/records/algorithms/bounded-repair-loop), [Severity Failure Routing](/records/algorithms/severity-failure-routing), [Verification Loop](/records/algorithms/verification-loop), [Verification Execution](/records/algorithms/verification-execution), [Reverification Gate](/records/algorithms/reverification-gate), [Evidence-Gated Claim Verification](/records/algorithms/evidence-gated-claim-verification), [Environment Capability Verification](/records/algorithms/environment-capability-verification), [Behavioral Self-Test](/records/algorithms/behavioral-self-test), [Adversarial Input Testing](/records/algorithms/adversarial-input-testing), [Recursive Self-Verification](/records/algorithms/recursive-self-verification), [Evidence Verdict](/records/algorithms/evidence-verdict), [PAG Handoff Gate](/records/algorithms/pag-validation-gate), [Anti-Pattern Elimination Verification](/records/algorithms/anti-pattern-elimination-verification), [Distillation Metrics](/records/algorithms/distillation-metrics), [Delta Capture](/records/algorithms/delta-capture), [Plan Phase Verification](/records/algorithms/plan-phase-verification), [Machine Verdict Derivation](/records/algorithms/machine-verdict-derivation), [Mode Contract Validation](/records/algorithms/mode-contract-validation), [Discovery Verification](/records/algorithms/discovery-verification), [Alignment Cadence](/records/algorithms/alignment-cadence)",
                    "term": "Contracts"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the reasoning-native check, which requires every process grammar's kernel to map the loop's stages and every staged record to name a real stage and that stage's axis",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every process grammar, its kernel and its staged records",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the loop, a grammar or a staged record changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on an unknown stage, a stage whose axis does not match, or a kernel that omits the verify stage",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because the loop is a procedure the grammars instantiate, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants an unknown stage, a mismatched axis and a kernel that omits the verify stage, and passes a fully typed staged record",
                    "term": "Evidence"
                  },
                  {
                    "description": "The loop's stage list, which every kernel and staged record cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "stage-verify",
            "title": "verify"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [representation](/records/reasoning/axis-representation)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "[Audit Artifact](/records/algorithms/audit-artifact), [Final Generation Report](/records/algorithms/final-generation-report), [Template Assembly](/records/algorithms/template-assembly), [Automation Session Report](/records/algorithms/automation-session-report), [Centralization Report](/records/algorithms/centralization-report), [Rendering Stage](/records/algorithms/rendering-stage), [Checklist Output Rendering](/records/algorithms/checklist-output-rendering), [Partial Success Reporting](/records/algorithms/partial-success-reporting), [Completion Report](/records/algorithms/completion-report), [Investigation Report](/records/algorithms/investigation-report), [Action Log](/records/algorithms/action-log), [Convergence Walk](/records/algorithms/convergence-walk), [Coverage Ledger](/records/algorithms/coverage-ledger), [Pattern Distillation History](/records/algorithms/pattern-distillation-history), [Version Provenance](/records/algorithms/version-provenance), [Living Plan State](/records/algorithms/living-plan-state), [Versioned Turn Provenance](/records/algorithms/versioned-turn-provenance), [Taxonomy Ledger](/records/algorithms/taxonomy-ledger)",
                    "term": "Contracts"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the reasoning-native check, which requires every process grammar's kernel to map the loop's stages and every staged record to name a real stage and that stage's axis",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every process grammar, its kernel and its staged records",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the loop, a grammar or a staged record changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on an unknown stage, a stage whose axis does not match, or a kernel that omits the verify stage",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because the loop is a procedure the grammars instantiate, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants an unknown stage, a mismatched axis and a kernel that omits the verify stage, and passes a fully typed staged record",
                    "term": "Evidence"
                  },
                  {
                    "description": "The loop's stage list, which every kernel and staged record cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "stage-commit",
            "title": "commit"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [termination](/records/reasoning/axis-termination)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "[Agent Generation Completion](/records/algorithms/agent-generation-completion), [First-Time Initiation](/records/algorithms/first-time-initiation), [Automation Completion Status](/records/algorithms/automation-completion-status), [Completion Truthfulness](/records/algorithms/completion-truthfulness), [Explicit Termination](/records/algorithms/explicit-termination), [Early Success Exit](/records/algorithms/early-success-exit), [Iteration Bound](/records/algorithms/iteration-bound), [Validation Gate](/records/algorithms/validation-gate), [Coverage Completion](/records/algorithms/coverage-completion), [PAG Well-Formedness Validation](/records/algorithms/pag-well-formedness-validation), [Pattern Distillation Completion Truthfulness](/records/algorithms/pattern-distillation-completion-truthfulness), [Phase Close Gate](/records/algorithms/phase-close-gate), [Bounded Cascade Termination](/records/algorithms/bounded-cascade-termination), [Taxonomy Completion](/records/algorithms/taxonomy-completion)",
                    "term": "Contracts"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the reasoning-native check, which requires every process grammar's kernel to map the loop's stages and every staged record to name a real stage and that stage's axis",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every process grammar, its kernel and its staged records",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the loop, a grammar or a staged record changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on an unknown stage, a stage whose axis does not match, or a kernel that omits the verify stage",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because the loop is a procedure the grammars instantiate, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants an unknown stage, a mismatched axis and a kernel that omits the verify stage, and passes a fully typed staged record",
                    "term": "Evidence"
                  },
                  {
                    "description": "The loop's stage list, which every kernel and staged record cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "stage-terminate",
            "title": "terminate"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "[orient](/records/stage/orient) → [intent](/records/stage/intent) · Transition: sequences",
                    "term": "orient → intent"
                  },
                  {
                    "description": "[intent](/records/stage/intent) → [see](/records/stage/see) · Transition: gates · Gate: tel-priority · On fail: redirect",
                    "term": "intent → see"
                  },
                  {
                    "description": "[see](/records/stage/see) → [derive](/records/stage/derive) · Transition: sequences",
                    "term": "see → derive"
                  },
                  {
                    "description": "[derive](/records/stage/derive) → [project](/records/stage/project) · Transition: sequences",
                    "term": "derive → project"
                  },
                  {
                    "description": "[project](/records/stage/project) → [act](/records/stage/act) · Transition: sequences",
                    "term": "project → act"
                  },
                  {
                    "description": "[act](/records/stage/act) → [constrain](/records/stage/constrain) · Transition: sequences",
                    "term": "act → constrain"
                  },
                  {
                    "description": "[constrain](/records/stage/constrain) → [verify](/records/stage/verify) · Transition: sequences",
                    "term": "constrain → verify"
                  },
                  {
                    "description": "[verify](/records/stage/verify) → [derive](/records/stage/derive) · Transition: refutes-back · Gate: ver-evidence · On fail: derive",
                    "term": "verify → derive"
                  },
                  {
                    "description": "[verify](/records/stage/verify) → [commit](/records/stage/commit) · Transition: sequences",
                    "term": "verify → commit"
                  },
                  {
                    "description": "[commit](/records/stage/commit) → [terminate](/records/stage/terminate) · Transition: sequences",
                    "term": "commit → terminate"
                  },
                  {
                    "description": "[terminate](/records/stage/terminate) → [orient](/records/stage/orient) · Transition: sequences · Gate: ter-stop · On pass: stop",
                    "term": "terminate → orient"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "title": "The transitions"
          }
        ],
        "title": "The derivation loop"
      },
      {
        "blocks": [
          {
            "caption": "The substrate cycle and its recursion.",
            "kind": "mermaid",
            "text": "flowchart LR\n    n_existence[\"existence\"]\n    n_difference[\"difference\"]\n    n_relation[\"relation\"]\n    n_structure[\"structure\"]\n    n_transformation[\"transformation\"]\n    n_constraint[\"constraint\"]\n    n_emergence[\"emergence\"]\n    n_existence --> n_difference\n    n_difference --> n_relation\n    n_relation --> n_structure\n    n_structure --> n_transformation\n    n_transformation --> n_constraint\n    n_constraint --> n_emergence\n    n_emergence -.-> n_difference"
          },
          {
            "kind": "text",
            "text": "Recursion · [emergence](/records/reasoning/substrate-node-emergence) → [difference](/records/reasoning/substrate-node-difference)"
          }
        ],
        "icon": "bi-signpost-split",
        "id": "the-substrate",
        "intro": "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.",
        "subsections": [
          {
            "blocks": [
              {
                "items": [
                  "Layer: [Substrate](/records/reasoning/layer-substrate)",
                  "Math type: [set-theory](/records/reasoning/math-type-set-theory)"
                ],
                "kind": "list"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over every model step, math type, genesis tag and construct that names a substrate node",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every model, document construct and genesis tag that names the substrate node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the substrate or a record that names one of its nodes changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a reference to a substrate node that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a substrate node is a primitive of pattern formation, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a step outside its model's step kind, another plants a ground whose kind exists and whose id does not, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The substrate node list, which every step, math type, tag and construct that names a node cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-substrate-node-existence",
            "title": "Existence"
          },
          {
            "blocks": [
              {
                "items": [
                  "Layer: [Substrate](/records/reasoning/layer-substrate)",
                  "Math type: [logic](/records/reasoning/math-type-logic)"
                ],
                "kind": "list"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over every model step, math type, genesis tag and construct that names a substrate node",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every model, document construct and genesis tag that names the substrate node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the substrate or a record that names one of its nodes changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a reference to a substrate node that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a substrate node is a primitive of pattern formation, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a step outside its model's step kind, another plants a ground whose kind exists and whose id does not, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The substrate node list, which every step, math type, tag and construct that names a node cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-substrate-node-difference",
            "title": "Difference"
          },
          {
            "blocks": [
              {
                "items": [
                  "Layer: [Substrate](/records/reasoning/layer-substrate)",
                  "Math type: [graph](/records/reasoning/math-type-graph)"
                ],
                "kind": "list"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over every model step, math type, genesis tag and construct that names a substrate node",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every model, document construct and genesis tag that names the substrate node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the substrate or a record that names one of its nodes changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a reference to a substrate node that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a substrate node is a primitive of pattern formation, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a step outside its model's step kind, another plants a ground whose kind exists and whose id does not, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The substrate node list, which every step, math type, tag and construct that names a node cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-substrate-node-relation",
            "title": "Relation"
          },
          {
            "blocks": [
              {
                "items": [
                  "Layer: [Substrate](/records/reasoning/layer-substrate)",
                  "Math type: [algebra](/records/reasoning/math-type-algebra)"
                ],
                "kind": "list"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over every model step, math type, genesis tag and construct that names a substrate node",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every model, document construct and genesis tag that names the substrate node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the substrate or a record that names one of its nodes changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a reference to a substrate node that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a substrate node is a primitive of pattern formation, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a step outside its model's step kind, another plants a ground whose kind exists and whose id does not, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The substrate node list, which every step, math type, tag and construct that names a node cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-substrate-node-structure",
            "title": "Structure"
          },
          {
            "blocks": [
              {
                "items": [
                  "Layer: [Substrate](/records/reasoning/layer-substrate)",
                  "Math type: [analysis](/records/reasoning/math-type-analysis)"
                ],
                "kind": "list"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over every model step, math type, genesis tag and construct that names a substrate node",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every model, document construct and genesis tag that names the substrate node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the substrate or a record that names one of its nodes changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a reference to a substrate node that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a substrate node is a primitive of pattern formation, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a step outside its model's step kind, another plants a ground whose kind exists and whose id does not, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The substrate node list, which every step, math type, tag and construct that names a node cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-substrate-node-transformation",
            "title": "Transformation"
          },
          {
            "blocks": [
              {
                "items": [
                  "Layer: [Substrate](/records/reasoning/layer-substrate)",
                  "Math type: [optimization](/records/reasoning/math-type-optimization)"
                ],
                "kind": "list"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over every model step, math type, genesis tag and construct that names a substrate node",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every model, document construct and genesis tag that names the substrate node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the substrate or a record that names one of its nodes changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a reference to a substrate node that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a substrate node is a primitive of pattern formation, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a step outside its model's step kind, another plants a ground whose kind exists and whose id does not, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The substrate node list, which every step, math type, tag and construct that names a node cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-substrate-node-constraint",
            "title": "Constraint"
          },
          {
            "blocks": [
              {
                "items": [
                  "Layer: [Substrate](/records/reasoning/layer-substrate)",
                  "Math type: [topology](/records/reasoning/math-type-topology)"
                ],
                "kind": "list"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over every model step, math type, genesis tag and construct that names a substrate node",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every model, document construct and genesis tag that names the substrate node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the substrate or a record that names one of its nodes changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a reference to a substrate node that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a substrate node is a primitive of pattern formation, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a step outside its model's step kind, another plants a ground whose kind exists and whose id does not, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The substrate node list, which every step, math type, tag and construct that names a node cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-substrate-node-invariant",
            "title": "Invariant"
          },
          {
            "blocks": [
              {
                "items": [
                  "Layer: [Substrate](/records/reasoning/layer-substrate)",
                  "Math type: [probability](/records/reasoning/math-type-probability)"
                ],
                "kind": "list"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over every model step, math type, genesis tag and construct that names a substrate node",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every model, document construct and genesis tag that names the substrate node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the substrate or a record that names one of its nodes changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a reference to a substrate node that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a substrate node is a primitive of pattern formation, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a step outside its model's step kind, another plants a ground whose kind exists and whose id does not, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The substrate node list, which every step, math type, tag and construct that names a node cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-substrate-node-uncertainty",
            "title": "Uncertainty"
          },
          {
            "blocks": [
              {
                "items": [
                  "Layer: [Substrate](/records/reasoning/layer-substrate)",
                  "Math type: [information-theory](/records/reasoning/math-type-information-theory)"
                ],
                "kind": "list"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over every model step, math type, genesis tag and construct that names a substrate node",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every model, document construct and genesis tag that names the substrate node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the substrate or a record that names one of its nodes changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a reference to a substrate node that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a substrate node is a primitive of pattern formation, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a step outside its model's step kind, another plants a ground whose kind exists and whose id does not, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The substrate node list, which every step, math type, tag and construct that names a node cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-substrate-node-information",
            "title": "Information"
          },
          {
            "blocks": [
              {
                "items": [
                  "Layer: [Substrate](/records/reasoning/layer-substrate)",
                  "Math type: [computation](/records/reasoning/math-type-computation)"
                ],
                "kind": "list"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over every model step, math type, genesis tag and construct that names a substrate node",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every model, document construct and genesis tag that names the substrate node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the substrate or a record that names one of its nodes changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a reference to a substrate node that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a substrate node is a primitive of pattern formation, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a step outside its model's step kind, another plants a ground whose kind exists and whose id does not, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The substrate node list, which every step, math type, tag and construct that names a node cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-substrate-node-procedure",
            "title": "Procedure"
          },
          {
            "blocks": [
              {
                "items": [
                  "Layer: [Substrate](/records/reasoning/layer-substrate)",
                  "Math type: [dynamical-systems](/records/reasoning/math-type-dynamical-systems)"
                ],
                "kind": "list"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over every model step, math type, genesis tag and construct that names a substrate node",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every model, document construct and genesis tag that names the substrate node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the substrate or a record that names one of its nodes changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a reference to a substrate node that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a substrate node is a primitive of pattern formation, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a step outside its model's step kind, another plants a ground whose kind exists and whose id does not, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The substrate node list, which every step, math type, tag and construct that names a node cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-substrate-node-emergence",
            "title": "Emergence"
          }
        ],
        "title": "The substrate"
      },
      {
        "icon": "bi-signpost-split",
        "id": "the-reasoning-layers",
        "intro": "The reasoning axes are arranged on these layers, each listed with the question it answers and the axes it holds.",
        "subsections": [
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "How does anything come to be?",
                    "term": "Question"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate, which requires every axis and substrate node that names a layer to resolve",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every axis and substrate node that names the layer",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the layer list or a record that names a layer changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on an axis or substrate node that names a layer that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a layer is a grouping of axes, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants an axis that names a missing layer, and the bundled references resolve",
                    "term": "Evidence"
                  },
                  {
                    "description": "The layer list, which every axis and substrate node that names a layer cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-layer-substrate",
            "title": "Substrate"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "How is it known?",
                    "term": "Question"
                  },
                  {
                    "description": "[ontology](/records/reasoning/axis-ontology), [analysis](/records/reasoning/axis-analysis), [reasoning](/records/reasoning/axis-reasoning), [representation](/records/reasoning/axis-representation), [formalization](/records/reasoning/axis-formalization)",
                    "term": "Axes"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate, which requires every axis and substrate node that names a layer to resolve",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every axis and substrate node that names the layer",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the layer list or a record that names a layer changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on an axis or substrate node that names a layer that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a layer is a grouping of axes, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants an axis that names a missing layer, and the bundled references resolve",
                    "term": "Evidence"
                  },
                  {
                    "description": "The layer list, which every axis and substrate node that names a layer cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-layer-epistemic",
            "title": "Epistemic"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "What is worth doing?",
                    "term": "Question"
                  },
                  {
                    "description": "[teleology](/records/reasoning/axis-teleology)",
                    "term": "Axes"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate, which requires every axis and substrate node that names a layer to resolve",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every axis and substrate node that names the layer",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the layer list or a record that names a layer changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on an axis or substrate node that names a layer that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a layer is a grouping of axes, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants an axis that names a missing layer, and the bundled references resolve",
                    "term": "Evidence"
                  },
                  {
                    "description": "The layer list, which every axis and substrate node that names a layer cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-layer-conative",
            "title": "Conative"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "Is it right, and is it done?",
                    "term": "Question"
                  },
                  {
                    "description": "[verification](/records/reasoning/axis-verification), [termination](/records/reasoning/axis-termination)",
                    "term": "Axes"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate, which requires every axis and substrate node that names a layer to resolve",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every axis and substrate node that names the layer",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the layer list or a record that names a layer changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on an axis or substrate node that names a layer that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a layer is a grouping of axes, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants an axis that names a missing layer, and the bundled references resolve",
                    "term": "Evidence"
                  },
                  {
                    "description": "The layer list, which every axis and substrate node that names a layer cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-layer-evaluative",
            "title": "Evaluative"
          }
        ],
        "title": "The reasoning layers"
      },
      {
        "icon": "bi-signpost-split",
        "id": "the-axes",
        "intro": "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.",
        "subsections": [
          {
            "blocks": [
              {
                "items": [
                  "Layer: [Epistemic](/records/reasoning/layer-epistemic)",
                  "Mandatory: when-relevant",
                  "Math type: [set-theory](/records/reasoning/math-type-set-theory)",
                  "Selectable: yes"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "What is it?",
                    "term": "Question"
                  },
                  {
                    "description": "[ont-identity](/records/reasoning/node-ont-identity), [ont-composition](/records/reasoning/node-ont-composition), [ont-structure](/records/reasoning/node-ont-structure), [ont-relation](/records/reasoning/node-ont-relation), [ont-space](/records/reasoning/node-ont-space), [ont-time](/records/reasoning/node-ont-time), [ont-state](/records/reasoning/node-ont-state), [ont-change](/records/reasoning/node-ont-change), [ont-behavior](/records/reasoning/node-ont-behavior), [ont-function](/records/reasoning/node-ont-function), [ont-cause](/records/reasoning/node-ont-cause), [ont-meaning](/records/reasoning/node-ont-meaning), [ont-scale](/records/reasoning/node-ont-scale), [ont-probability](/records/reasoning/node-ont-probability), [ont-novelty](/records/reasoning/node-ont-novelty)",
                    "term": "Nodes"
                  },
                  {
                    "description": "[Evidence-Before-Generation](/records/algorithms/evidence-before-generation), [Semantic Operation Boundary](/records/algorithms/semantic-operation-boundary), [Capability Profile](/records/algorithms/capability-profile), [Domain Cache Validation](/records/algorithms/domain-cache-validation), [Scope Extraction](/records/algorithms/scope-extraction), [Domain Knowledge Base](/records/algorithms/domain-knowledge-base), [DSL Compliance Loading](/records/algorithms/dsl-compliance-loading), [Workspace Configuration Discovery](/records/algorithms/workspace-configuration-discovery), [Runtime-Neutral Automation Boundary](/records/algorithms/runtime-neutral-automation-boundary), [Capability Degradation](/records/algorithms/capability-degradation), [Automation Opportunity Detection](/records/algorithms/automation-opportunity-detection), [Runtime-Agnostic Adapter Boundary](/records/algorithms/runtime-agnostic-adapter-boundary), [Capability Disclosure](/records/algorithms/capability-disclosure), [Iterative Variation Discovery](/records/algorithms/iterative-variation-discovery), [Detection Registry](/records/algorithms/detection-registry), [Orientation Stage](/records/algorithms/orientation-stage), [Authoritative Source Loading](/records/algorithms/authoritative-source-loading), [Trust Anchor](/records/algorithms/trust-anchor), [Intent & Directionality Normalization](/records/algorithms/intent-directionality-normalization), [Skeptical Context Acquisition](/records/algorithms/skeptical-context-acquisition), [Dynamic Discovery Pattern Generation](/records/algorithms/dynamic-discovery-pattern-generation), [Context Initialization](/records/algorithms/context-initialization), [Trust Anchor Declaration](/records/algorithms/trust-anchor-declaration), [Coverage Workspace](/records/algorithms/coverage-workspace), [PAG Document Declaration](/records/algorithms/pag-document-declaration), [Analysis Workspace](/records/algorithms/analysis-workspace), [Registry Baseline](/records/algorithms/registry-baseline), [Profile Compose](/records/algorithms/profile-compose), [Seed Composition](/records/algorithms/seed-composition), [Taxonomy Jurisdiction](/records/algorithms/taxonomy-jurisdiction)",
                    "term": "Contracts"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate, which requires every node, loop stage and grammar ground that names an axis to resolve",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every reasoning node, loop stage and algorithm record that names the axis",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the axis list or a record that names an axis changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a node, stage or ground that names an axis that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because an axis is a category of question, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a node whose axis does not exist and a staged record whose axis is not its stage's axis, and the bundled records validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The axis list, which every node, stage and ground that names an axis cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-axis-ontology",
            "title": "ontology"
          },
          {
            "blocks": [
              {
                "items": [
                  "Layer: [Epistemic](/records/reasoning/layer-epistemic)",
                  "Mandatory: when-relevant",
                  "Math type: [graph](/records/reasoning/math-type-graph)",
                  "Selectable: yes"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "How is it to be seen?",
                    "term": "Question"
                  },
                  {
                    "description": "[ana-structural](/records/reasoning/node-ana-structural), [ana-temporal](/records/reasoning/node-ana-temporal), [ana-spatial](/records/reasoning/node-ana-spatial), [ana-statistical](/records/reasoning/node-ana-statistical), [ana-frequency](/records/reasoning/node-ana-frequency), [ana-sequential](/records/reasoning/node-ana-sequential), [ana-relational](/records/reasoning/node-ana-relational), [ana-behavioral](/records/reasoning/node-ana-behavioral), [ana-functional](/records/reasoning/node-ana-functional), [ana-semantic](/records/reasoning/node-ana-semantic), [ana-causal](/records/reasoning/node-ana-causal), [ana-predictive](/records/reasoning/node-ana-predictive), [ana-anomaly](/records/reasoning/node-ana-anomaly), [ana-evolutionary](/records/reasoning/node-ana-evolutionary), [ana-fractal](/records/reasoning/node-ana-fractal)",
                    "term": "Nodes"
                  },
                  {
                    "description": "[Non-Destructive Domain Investigation](/records/algorithms/non-destructive-domain-investigation), [Risk Complexity Reversibility](/records/algorithms/risk-complexity-reversibility), [Existing Pattern Extraction](/records/algorithms/existing-pattern-extraction), [Knowledge Documentation Relevance](/records/algorithms/knowledge-documentation-relevance), [Breaking Point Calculation](/records/algorithms/breaking-point-calculation), [Convention Strength Analysis](/records/algorithms/convention-strength-analysis), [Scalability Projection](/records/algorithms/scalability-projection), [Research Guidance](/records/algorithms/research-guidance), [Tool Calibration](/records/algorithms/tool-calibration), [Lifetime Resolution](/records/algorithms/lifetime-resolution), [Surface Grid Walk](/records/algorithms/surface-grid-walk), [PAG Keyword Ontology](/records/algorithms/pag-keyword-ontology), [Compliance Gap](/records/algorithms/compliance-gap), [Semantic Domain Partitioning](/records/algorithms/semantic-domain-partitioning), [Behavioral Signature Extraction](/records/algorithms/behavioral-signature-extraction), [Cross-Class Pattern Detection](/records/algorithms/cross-class-pattern-detection), [Behavioral Inconsistency](/records/algorithms/behavioral-inconsistency), [Sequential Chain Duplication](/records/algorithms/sequential-chain-duplication), [Temporal Coupling Detection](/records/algorithms/temporal-coupling-detection), [Relational Graph Duplication](/records/algorithms/relational-graph-duplication), [Causal Wiring Duplication](/records/algorithms/causal-wiring-duplication), [Anomaly Outlier Detection](/records/algorithms/anomaly-outlier-detection), [Conceptual Duplication Detection](/records/algorithms/conceptual-duplication-detection), [Fractal Scale Duplication](/records/algorithms/fractal-scale-duplication), [Path Role Walk](/records/algorithms/path-role-walk)",
                    "term": "Contracts"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate, which requires every node, loop stage and grammar ground that names an axis to resolve",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every reasoning node, loop stage and algorithm record that names the axis",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the axis list or a record that names an axis changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a node, stage or ground that names an axis that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because an axis is a category of question, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a node whose axis does not exist and a staged record whose axis is not its stage's axis, and the bundled records validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The axis list, which every node, stage and ground that names an axis cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-axis-analysis",
            "title": "analysis"
          },
          {
            "blocks": [
              {
                "items": [
                  "Layer: [Epistemic](/records/reasoning/layer-epistemic)",
                  "Mandatory: when-relevant",
                  "Math type: [logic](/records/reasoning/math-type-logic)",
                  "Selectable: yes"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Why, and what follows?",
                    "term": "Question"
                  },
                  {
                    "description": "[rea-observation](/records/reasoning/node-rea-observation), [rea-description](/records/reasoning/node-rea-description), [rea-comparison](/records/reasoning/node-rea-comparison), [rea-classification](/records/reasoning/node-rea-classification), [rea-explanation](/records/reasoning/node-rea-explanation), [rea-prediction](/records/reasoning/node-rea-prediction), [rea-intervention](/records/reasoning/node-rea-intervention), [rea-creation](/records/reasoning/node-rea-creation), [rea-reflection](/records/reasoning/node-rea-reflection)",
                    "term": "Nodes"
                  },
                  {
                    "description": "[Principle Extraction](/records/algorithms/principle-extraction), [Phase Validation Requirement](/records/algorithms/phase-validation-requirement), [Validation Strategy Composition](/records/algorithms/validation-strategy-composition), [Hybrid Workflow Orchestration](/records/algorithms/hybrid-workflow-orchestration), [Context Forking Configuration](/records/algorithms/context-forking-configuration), [Verb-Based Execution Classification](/records/algorithms/verb-based-execution-classification), [Workflow Type Document Selection](/records/algorithms/workflow-type-document-selection), [Agent Sequence Definition](/records/algorithms/agent-sequence-definition), [Four-Dimensional Agent Graph](/records/algorithms/four-dimensional-agent-graph), [Workflow Principles Mapping](/records/algorithms/workflow-principles-mapping), [Intentional Static Separation](/records/algorithms/intentional-static-separation), [Extension Interface Discovery](/records/algorithms/extension-interface-discovery), [Performance-Aware Discovery Design](/records/algorithms/performance-aware-discovery-design), [Dynamic Extension Architecture](/records/algorithms/dynamic-extension-architecture), [Pattern Classification](/records/algorithms/pattern-classification), [Refactor Intent Classification](/records/algorithms/refactor-intent-classification), [Architecture Compliance Targeting](/records/algorithms/architecture-compliance-targeting), [Existing Solution Conflict](/records/algorithms/existing-solution-conflict), [Migration Action Mapping](/records/algorithms/migration-action-mapping), [Atomic Refactor Phase](/records/algorithms/atomic-refactor-phase), [Planning Stage](/records/algorithms/planning-stage), [Principle Activation](/records/algorithms/principle-activation), [Protocol Semantic Selection](/records/algorithms/protocol-semantic-selection), [Phase Decomposition](/records/algorithms/phase-decomposition), [Four-Dimensional Phase Graph](/records/algorithms/four-dimensional-phase-graph), [Dependency Linearization](/records/algorithms/dependency-linearization), [Severity Assignment](/records/algorithms/severity-assignment), [Loop Class Labeling](/records/algorithms/loop-class-labeling), [Violation Classification](/records/algorithms/violation-classification), [Invocation Join](/records/algorithms/invocation-join), [Duplicate Disposition Walk](/records/algorithms/duplicate-disposition-walk), [Uncovered Gap Derivation](/records/algorithms/uncovered-gap-derivation), [Technique and Invariant Selection](/records/algorithms/technique-invariant-selection), [PAG Node Decomposition](/records/algorithms/pag-node-decomposition), [PAG Structure Declaration](/records/algorithms/pag-coordination-construct), [PAG Ambiguity Reduction](/records/algorithms/pag-ambiguity-reduction), [Anti-Pattern Classification](/records/algorithms/anti-pattern-classification), [Abstraction Boundary Principle](/records/algorithms/abstraction-boundary-principle), [Base-Class Candidate Selection](/records/algorithms/base-class-candidate-selection), [Concrete-vs-Abstract Responsibility Split](/records/algorithms/concrete-vs-abstract-responsibility-split), [Template Method Lifecycle](/records/algorithms/template-method-lifecycle), [Migration Ordering](/records/algorithms/migration-ordering), [Canonical Config Resolution](/records/algorithms/canonical-config-resolution), [Stage Ordering](/records/algorithms/stage-ordering), [Concern Classification](/records/algorithms/concern-classification), [Name Projection](/records/algorithms/name-projection), [Container Ladder](/records/algorithms/container-ladder), [Export Triage Ladder](/records/algorithms/export-triage-ladder), [Dialect Resolution](/records/algorithms/dialect-resolution)",
                    "term": "Contracts"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate, which requires every node, loop stage and grammar ground that names an axis to resolve",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every reasoning node, loop stage and algorithm record that names the axis",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the axis list or a record that names an axis changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a node, stage or ground that names an axis that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because an axis is a category of question, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a node whose axis does not exist and a staged record whose axis is not its stage's axis, and the bundled records validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The axis list, which every node, stage and ground that names an axis cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-axis-reasoning",
            "title": "reasoning"
          },
          {
            "blocks": [
              {
                "items": [
                  "Layer: [Epistemic](/records/reasoning/layer-epistemic)",
                  "Mandatory: when-relevant",
                  "Math type: [information-theory](/records/reasoning/math-type-information-theory)",
                  "Selectable: yes"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "How is it encoded?",
                    "term": "Question"
                  },
                  {
                    "description": "[rep-symbolic](/records/reasoning/node-rep-symbolic), [rep-numerical](/records/reasoning/node-rep-numerical), [rep-geometric](/records/reasoning/node-rep-geometric), [rep-topological](/records/reasoning/node-rep-topological), [rep-information-theoretic](/records/reasoning/node-rep-information-theoretic), [rep-probabilistic](/records/reasoning/node-rep-probabilistic), [rep-dynamical](/records/reasoning/node-rep-dynamical), [rep-computational](/records/reasoning/node-rep-computational)",
                    "term": "Nodes"
                  },
                  {
                    "description": "[Audit Artifact](/records/algorithms/audit-artifact), [Final Generation Report](/records/algorithms/final-generation-report), [Template Assembly](/records/algorithms/template-assembly), [Automation Session Report](/records/algorithms/automation-session-report), [Centralization Report](/records/algorithms/centralization-report), [Rendering Stage](/records/algorithms/rendering-stage), [Checklist Output Rendering](/records/algorithms/checklist-output-rendering), [Partial Success Reporting](/records/algorithms/partial-success-reporting), [Completion Report](/records/algorithms/completion-report), [Investigation Report](/records/algorithms/investigation-report), [Action Log](/records/algorithms/action-log), [Convergence Walk](/records/algorithms/convergence-walk), [Coverage Ledger](/records/algorithms/coverage-ledger), [Pattern Distillation History](/records/algorithms/pattern-distillation-history), [Version Provenance](/records/algorithms/version-provenance), [Living Plan State](/records/algorithms/living-plan-state), [Versioned Turn Provenance](/records/algorithms/versioned-turn-provenance), [Taxonomy Ledger](/records/algorithms/taxonomy-ledger)",
                    "term": "Contracts"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate, which requires every node, loop stage and grammar ground that names an axis to resolve",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every reasoning node, loop stage and algorithm record that names the axis",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the axis list or a record that names an axis changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a node, stage or ground that names an axis that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because an axis is a category of question, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a node whose axis does not exist and a staged record whose axis is not its stage's axis, and the bundled records validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The axis list, which every node, stage and ground that names an axis cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-axis-representation",
            "title": "representation"
          },
          {
            "blocks": [
              {
                "items": [
                  "Layer: [Epistemic](/records/reasoning/layer-epistemic)",
                  "Mandatory: when-relevant",
                  "Math type: [computation](/records/reasoning/math-type-computation)",
                  "Selectable: yes"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "What does it resolve to?",
                    "term": "Question"
                  },
                  {
                    "description": "[for-existence](/records/reasoning/node-for-existence), [for-structure](/records/reasoning/node-for-structure), [for-relation](/records/reasoning/node-for-relation), [for-space](/records/reasoning/node-for-space), [for-transformation](/records/reasoning/node-for-transformation), [for-invariance](/records/reasoning/node-for-invariance), [for-uncertainty](/records/reasoning/node-for-uncertainty), [for-computation](/records/reasoning/node-for-computation), [for-abstraction](/records/reasoning/node-for-abstraction), [for-creation](/records/reasoning/node-for-creation), [for-absence](/records/reasoning/node-for-absence)",
                    "term": "Nodes"
                  },
                  {
                    "description": "[Portable Contract Composition](/records/algorithms/portable-contract-composition), [Adapter Rendering](/records/algorithms/adapter-rendering), [Agent Workflow File Modification Recovery](/records/algorithms/agent-workflow-file-modification-recovery), [Shared Document Workspace](/records/algorithms/shared-document-workspace), [Agent Document Responsibility](/records/algorithms/agent-document-responsibility), [Agent Activation Invocation](/records/algorithms/agent-activation-invocation), [Parallel Batch Execution](/records/algorithms/parallel-batch-execution), [Sequential Agent Execution](/records/algorithms/sequential-agent-execution), [Handoff Signal](/records/algorithms/handoff-signal), [Orchestrator Action](/records/algorithms/orchestrator-action), [Workflow Coordination Sequence](/records/algorithms/workflow-coordination-sequence), [Workflow Recovery Loop](/records/algorithms/workflow-recovery-loop), [Checklist Integration](/records/algorithms/checklist-integration), [Phase Documentation Template](/records/algorithms/phase-documentation-template), [Capability Invocation Protocol](/records/algorithms/capability-invocation-protocol), [Centralized Reference Resolver](/records/algorithms/centralized-reference-resolver), [Cache Invalidation Strategy](/records/algorithms/cache-invalidation-strategy), [Manual Fallback Preservation](/records/algorithms/manual-fallback-preservation), [Dynamic Failure Isolation](/records/algorithms/dynamic-failure-isolation), [Entry Point Migration](/records/algorithms/entry-point-migration), [Knowledge Capture](/records/algorithms/knowledge-capture), [Replacement Refactor](/records/algorithms/replacement-refactor), [Rollback-Centered Execution](/records/algorithms/rollback-centered-execution), [Compilation Stage](/records/algorithms/compilation-stage), [Codebase Pattern Enforcement](/records/algorithms/codebase-pattern-enforcement), [Verb Template Binding](/records/algorithms/verb-template-binding), [Task Atomization](/records/algorithms/task-atomization), [Ripple Chain Analysis](/records/algorithms/ripple-chain-analysis), [Validator Coverage](/records/algorithms/validator-coverage), [Structured Observability Context](/records/algorithms/structured-observability-context), [Cross-Cutting Surface Coverage](/records/algorithms/cross-cutting-surface-coverage), [Legacy Elimination](/records/algorithms/legacy-elimination), [Hierarchical Numbering](/records/algorithms/hierarchical-numbering), [File-Scoped Fix](/records/algorithms/file-scoped-fix), [File Limit Remediation](/records/algorithms/file-limit-remediation), [Import Boundary Remediation](/records/algorithms/import-boundary-remediation), [Naming Convention Remediation](/records/algorithms/naming-convention-remediation), [Base-Class Compliance Remediation](/records/algorithms/base-class-compliance-remediation), [CSS Token Remediation](/records/algorithms/css-token-remediation), [DOM Factory Remediation](/records/algorithms/dom-factory-remediation), [Console Usage Remediation](/records/algorithms/console-usage-remediation), [Lifecycle Symmetry Remediation](/records/algorithms/lifecycle-symmetry-remediation), [Stylelint Post-Fix](/records/algorithms/stylelint-post-fix), [File Modification Recovery](/records/algorithms/file-modification-recovery), [Defensive String Normalization](/records/algorithms/defensive-string-normalization), [Safe Arithmetic Contract](/records/algorithms/safe-arithmetic-contract), [Recursion Control](/records/algorithms/recursion-control), [Advanced Tool Escalation](/records/algorithms/advanced-tool-escalation), [Test Authoring](/records/algorithms/test-authoring), [PAG Explicit Control Flow](/records/algorithms/pag-explicit-control-flow), [PAG Semantic Operation](/records/algorithms/pag-tool-invocation), [Base Schematic Composition](/records/algorithms/base-schematic-composition), [Backup-Verified Migration](/records/algorithms/backup-verified-migration), [Registry Regeneration](/records/algorithms/registry-regeneration), [Anti-Reintroduction Gate](/records/algorithms/anti-reintroduction-gate), [Idempotent Merge](/records/algorithms/idempotent-merge), [Deterministic Merge Core](/records/algorithms/deterministic-merge-core), [Persistence Fork](/records/algorithms/persistence-fork), [Comment Normalization Remediation](/records/algorithms/comment-normalization-remediation), [Custom-Rule Derivation](/records/algorithms/custom-rule-derivation), [Composed Turn Contract](/records/algorithms/composed-turn-contract), [Container Reshape](/records/algorithms/container-reshape)",
                    "term": "Contracts"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate, which requires every node, loop stage and grammar ground that names an axis to resolve",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every reasoning node, loop stage and algorithm record that names the axis",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the axis list or a record that names an axis changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a node, stage or ground that names an axis that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because an axis is a category of question, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a node whose axis does not exist and a staged record whose axis is not its stage's axis, and the bundled records validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The axis list, which every node, stage and ground that names an axis cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-axis-formalization",
            "title": "formalization"
          },
          {
            "blocks": [
              {
                "items": [
                  "Layer: [Conative](/records/reasoning/layer-conative)",
                  "Mandatory: always",
                  "Math type: [optimization](/records/reasoning/math-type-optimization)",
                  "Selectable: no"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "What is it for?",
                    "term": "Question"
                  },
                  {
                    "description": "[tel-objective](/records/reasoning/node-tel-objective), [tel-utility](/records/reasoning/node-tel-utility), [tel-cost](/records/reasoning/node-tel-cost), [tel-priority](/records/reasoning/node-tel-priority)",
                    "term": "Nodes"
                  },
                  {
                    "description": "[Creation History Collision](/records/algorithms/creation-history-collision), [Adaptive Phase Boundary](/records/algorithms/adaptive-phase-boundary), [Replacement Safety](/records/algorithms/replacement-safety), [Static-to-Dynamic Readiness](/records/algorithms/static-to-dynamic-readiness), [Automation Operation Mode](/records/algorithms/automation-operation-mode), [Automation Priority Ordering](/records/algorithms/automation-priority-ordering), [Operation Mode Gating](/records/algorithms/operation-mode-gating), [Canonical Variation Selection](/records/algorithms/canonical-variation-selection), [Developer Decision Gate](/records/algorithms/developer-decision-gate), [Teleological Intent Gate](/records/algorithms/teleological-intent-gate), [Admissibility Constraint Gate](/records/algorithms/admissibility-constraint-stage), [Severity-Ordered Remediation](/records/algorithms/severity-ordered-remediation), [Phase-Separated Execution](/records/algorithms/phase-separated-execution), [Coverage Risk Prioritization](/records/algorithms/coverage-risk-prioritization), [PAG Invariant Record](/records/algorithms/pag-constraint-boundary), [Anti-Pattern Priority Matrix](/records/algorithms/anti-pattern-priority-matrix), [Boundary Reconciliation](/records/algorithms/boundary-reconciliation), [Reshape Risk Priority](/records/algorithms/reshape-risk-priority), [Vocabulary Admission Gate](/records/algorithms/vocabulary-admission-gate)",
                    "term": "Contracts"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate, which requires every node, loop stage and grammar ground that names an axis to resolve",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every reasoning node, loop stage and algorithm record that names the axis",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the axis list or a record that names an axis changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a node, stage or ground that names an axis that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because an axis is a category of question, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a node whose axis does not exist and a staged record whose axis is not its stage's axis, and the bundled records validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The axis list, which every node, stage and ground that names an axis cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-axis-teleology",
            "title": "teleology"
          },
          {
            "blocks": [
              {
                "items": [
                  "Layer: [Evaluative](/records/reasoning/layer-evaluative)",
                  "Mandatory: always",
                  "Math type: [logic](/records/reasoning/math-type-logic)",
                  "Selectable: no"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Is it real?",
                    "term": "Question"
                  },
                  {
                    "description": "[ver-evidence](/records/reasoning/node-ver-evidence), [ver-ground-truth](/records/reasoning/node-ver-ground-truth), [ver-falsification](/records/reasoning/node-ver-falsification), [ver-confidence](/records/reasoning/node-ver-confidence), [ver-refutation](/records/reasoning/node-ver-refutation), [ver-population](/records/reasoning/node-ver-population), [ver-freshness](/records/reasoning/node-ver-freshness), [ver-standing](/records/reasoning/node-ver-standing), [ver-refusal](/records/reasoning/node-ver-refusal), [ver-observation](/records/reasoning/node-ver-observation)",
                    "term": "Nodes"
                  },
                  {
                    "description": "[Semantic Compliance Validation](/records/algorithms/semantic-compliance-validation), [Evidence Grounding Validation](/records/algorithms/evidence-grounding-validation), [Algorithmic Embodiment Validation](/records/algorithms/algorithmic-embodiment-validation), [Workflow Validation Gate](/records/algorithms/workflow-validation-gate), [Measured-vs-Estimated Validation](/records/algorithms/measured-vs-estimated-validation), [Architecture Validation Before Persistence](/records/algorithms/architecture-validation-before-persistence), [Additive Debt Gate](/records/algorithms/additive-debt-gate), [Pattern-Specific Validation](/records/algorithms/pattern-specific-validation), [Zero-Duplication Verification](/records/algorithms/zero-duplication-verification), [Validation Score](/records/algorithms/validation-score), [Validation Stage](/records/algorithms/validation-stage), [Semantic Debt Policy](/records/algorithms/semantic-debt-policy), [Evidence-Based Claim Verification](/records/algorithms/evidence-based-claim-verification), [Validation Suite Battery](/records/algorithms/validation-suite-battery), [Repair Stage](/records/algorithms/repair-stage), [Bounded Repair Loop](/records/algorithms/bounded-repair-loop), [Severity Failure Routing](/records/algorithms/severity-failure-routing), [Verification Loop](/records/algorithms/verification-loop), [Verification Execution](/records/algorithms/verification-execution), [Reverification Gate](/records/algorithms/reverification-gate), [Evidence-Gated Claim Verification](/records/algorithms/evidence-gated-claim-verification), [Environment Capability Verification](/records/algorithms/environment-capability-verification), [Behavioral Self-Test](/records/algorithms/behavioral-self-test), [Adversarial Input Testing](/records/algorithms/adversarial-input-testing), [Recursive Self-Verification](/records/algorithms/recursive-self-verification), [Evidence Verdict](/records/algorithms/evidence-verdict), [PAG Handoff Gate](/records/algorithms/pag-validation-gate), [Anti-Pattern Elimination Verification](/records/algorithms/anti-pattern-elimination-verification), [Distillation Metrics](/records/algorithms/distillation-metrics), [Delta Capture](/records/algorithms/delta-capture), [Plan Phase Verification](/records/algorithms/plan-phase-verification), [Machine Verdict Derivation](/records/algorithms/machine-verdict-derivation), [Mode Contract Validation](/records/algorithms/mode-contract-validation), [Discovery Verification](/records/algorithms/discovery-verification), [Alignment Cadence](/records/algorithms/alignment-cadence)",
                    "term": "Contracts"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate, which requires every node, loop stage and grammar ground that names an axis to resolve",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every reasoning node, loop stage and algorithm record that names the axis",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the axis list or a record that names an axis changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a node, stage or ground that names an axis that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because an axis is a category of question, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a node whose axis does not exist and a staged record whose axis is not its stage's axis, and the bundled records validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The axis list, which every node, stage and ground that names an axis cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-axis-verification",
            "title": "verification"
          },
          {
            "blocks": [
              {
                "items": [
                  "Layer: [Evaluative](/records/reasoning/layer-evaluative)",
                  "Mandatory: always",
                  "Math type: [set-theory](/records/reasoning/math-type-set-theory)",
                  "Selectable: no"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Is it done?",
                    "term": "Question"
                  },
                  {
                    "description": "[ter-completion](/records/reasoning/node-ter-completion), [ter-saturation](/records/reasoning/node-ter-saturation), [ter-diminishing-returns](/records/reasoning/node-ter-diminishing-returns), [ter-block](/records/reasoning/node-ter-block), [ter-stop](/records/reasoning/node-ter-stop), [ter-promotion](/records/reasoning/node-ter-promotion), [ter-publication](/records/reasoning/node-ter-publication)",
                    "term": "Nodes"
                  },
                  {
                    "description": "[Agent Generation Completion](/records/algorithms/agent-generation-completion), [First-Time Initiation](/records/algorithms/first-time-initiation), [Automation Completion Status](/records/algorithms/automation-completion-status), [Completion Truthfulness](/records/algorithms/completion-truthfulness), [Explicit Termination](/records/algorithms/explicit-termination), [Early Success Exit](/records/algorithms/early-success-exit), [Iteration Bound](/records/algorithms/iteration-bound), [Validation Gate](/records/algorithms/validation-gate), [Coverage Completion](/records/algorithms/coverage-completion), [PAG Well-Formedness Validation](/records/algorithms/pag-well-formedness-validation), [Pattern Distillation Completion Truthfulness](/records/algorithms/pattern-distillation-completion-truthfulness), [Phase Close Gate](/records/algorithms/phase-close-gate), [Bounded Cascade Termination](/records/algorithms/bounded-cascade-termination), [Taxonomy Completion](/records/algorithms/taxonomy-completion)",
                    "term": "Contracts"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate, which requires every node, loop stage and grammar ground that names an axis to resolve",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every reasoning node, loop stage and algorithm record that names the axis",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the axis list or a record that names an axis changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a node, stage or ground that names an axis that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because an axis is a category of question, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a node whose axis does not exist and a staged record whose axis is not its stage's axis, and the bundled records validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The axis list, which every node, stage and ground that names an axis cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-axis-termination",
            "title": "termination"
          }
        ],
        "title": "The axes"
      },
      {
        "icon": "bi-signpost-split",
        "id": "the-nodes",
        "intro": "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.",
        "subsections": [
          {
            "blocks": [
              {
                "items": [
                  "Axis: [ontology](/records/reasoning/axis-ontology)",
                  "Math type: [set-theory](/records/reasoning/math-type-set-theory)",
                  "Concept: [identity](/records/reasoning/dimension-identity)"
                ],
                "kind": "list"
              },
              {
                "entries": [],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-ont-identity",
            "title": "Identity"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [ontology](/records/reasoning/axis-ontology)",
                  "Math type: [set-theory](/records/reasoning/math-type-set-theory)",
                  "Concept: [composition](/records/reasoning/dimension-composition)"
                ],
                "kind": "list"
              },
              {
                "entries": [],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-ont-composition",
            "title": "Composition"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [ontology](/records/reasoning/axis-ontology)",
                  "Math type: [algebra](/records/reasoning/math-type-algebra)",
                  "Concept: [structure](/records/reasoning/dimension-structure)"
                ],
                "kind": "list"
              },
              {
                "entries": [],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-ont-structure",
            "title": "Structure"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [ontology](/records/reasoning/axis-ontology)",
                  "Math type: [graph](/records/reasoning/math-type-graph)",
                  "Concept: [relation](/records/reasoning/dimension-relation)"
                ],
                "kind": "list"
              },
              {
                "entries": [],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-ont-relation",
            "title": "Relation"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [ontology](/records/reasoning/axis-ontology)",
                  "Math type: [topology](/records/reasoning/math-type-topology)",
                  "Concept: [space](/records/reasoning/dimension-space)"
                ],
                "kind": "list"
              },
              {
                "entries": [],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-ont-space",
            "title": "Space"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [ontology](/records/reasoning/axis-ontology)",
                  "Math type: [analysis](/records/reasoning/math-type-analysis)",
                  "Concept: [time](/records/reasoning/dimension-time)"
                ],
                "kind": "list"
              },
              {
                "entries": [],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-ont-time",
            "title": "Time"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [ontology](/records/reasoning/axis-ontology)",
                  "Math type: [set-theory](/records/reasoning/math-type-set-theory)",
                  "Concept: [state](/records/reasoning/dimension-state)"
                ],
                "kind": "list"
              },
              {
                "entries": [],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-ont-state",
            "title": "State"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [ontology](/records/reasoning/axis-ontology)",
                  "Math type: [analysis](/records/reasoning/math-type-analysis)",
                  "Concept: [change](/records/reasoning/dimension-change)"
                ],
                "kind": "list"
              },
              {
                "entries": [],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-ont-change",
            "title": "Change"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [ontology](/records/reasoning/axis-ontology)",
                  "Math type: [dynamical-systems](/records/reasoning/math-type-dynamical-systems)",
                  "Concept: [behavior](/records/reasoning/dimension-behavior)"
                ],
                "kind": "list"
              },
              {
                "entries": [],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-ont-behavior",
            "title": "Behavior"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [ontology](/records/reasoning/axis-ontology)",
                  "Math type: [analysis](/records/reasoning/math-type-analysis)",
                  "Concept: [function](/records/reasoning/dimension-function)"
                ],
                "kind": "list"
              },
              {
                "entries": [],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-ont-function",
            "title": "Function"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [ontology](/records/reasoning/axis-ontology)",
                  "Math type: [analysis](/records/reasoning/math-type-analysis)",
                  "Concept: [cause](/records/reasoning/dimension-cause)"
                ],
                "kind": "list"
              },
              {
                "entries": [],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-ont-cause",
            "title": "Cause"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [ontology](/records/reasoning/axis-ontology)",
                  "Math type: [logic](/records/reasoning/math-type-logic)",
                  "Concept: [meaning](/records/reasoning/dimension-meaning)"
                ],
                "kind": "list"
              },
              {
                "entries": [],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-ont-meaning",
            "title": "Meaning"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [ontology](/records/reasoning/axis-ontology)",
                  "Math type: [topology](/records/reasoning/math-type-topology)",
                  "Concept: [scale](/records/reasoning/dimension-scale)"
                ],
                "kind": "list"
              },
              {
                "entries": [],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-ont-scale",
            "title": "Scale"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [ontology](/records/reasoning/axis-ontology)",
                  "Math type: [probability](/records/reasoning/math-type-probability)",
                  "Concept: [probability](/records/reasoning/dimension-probability)"
                ],
                "kind": "list"
              },
              {
                "entries": [],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-ont-probability",
            "title": "Probability"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [ontology](/records/reasoning/axis-ontology)",
                  "Math type: [probability](/records/reasoning/math-type-probability)",
                  "Concept: [novelty](/records/reasoning/dimension-novelty)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "[Concrete-vs-Abstract Responsibility Split](/records/algorithms/concrete-vs-abstract-responsibility-split)",
                    "term": "Grounded by"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-ont-novelty",
            "title": "Novelty"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [analysis](/records/reasoning/axis-analysis)",
                  "Math type: [algebra](/records/reasoning/math-type-algebra)",
                  "Concept: [structural](/records/reasoning/lens-structure)"
                ],
                "kind": "list"
              },
              {
                "entries": [],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-ana-structural",
            "title": "Structural Analysis"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [analysis](/records/reasoning/axis-analysis)",
                  "Math type: [analysis](/records/reasoning/math-type-analysis)",
                  "Concept: [temporal](/records/reasoning/lens-time)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "[Temporal Coupling Detection](/records/algorithms/temporal-coupling-detection)",
                    "term": "Grounded by"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-ana-temporal",
            "title": "Temporal Analysis"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [analysis](/records/reasoning/axis-analysis)",
                  "Math type: [topology](/records/reasoning/math-type-topology)",
                  "Concept: [spatial](/records/reasoning/lens-space)"
                ],
                "kind": "list"
              },
              {
                "entries": [],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-ana-spatial",
            "title": "Spatial Analysis"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [analysis](/records/reasoning/axis-analysis)",
                  "Math type: [probability](/records/reasoning/math-type-probability)",
                  "Concept: [statistical](/records/reasoning/lens-statistical)"
                ],
                "kind": "list"
              },
              {
                "entries": [],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-ana-statistical",
            "title": "Statistical Analysis"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [analysis](/records/reasoning/axis-analysis)",
                  "Math type: [information-theory](/records/reasoning/math-type-information-theory)",
                  "Concept: [frequency](/records/reasoning/lens-frequency)"
                ],
                "kind": "list"
              },
              {
                "entries": [],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-ana-frequency",
            "title": "Frequency Analysis"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [analysis](/records/reasoning/axis-analysis)",
                  "Math type: [logic](/records/reasoning/math-type-logic)",
                  "Concept: [sequential](/records/reasoning/lens-sequential)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "[Sequential Chain Duplication](/records/algorithms/sequential-chain-duplication)",
                    "term": "Grounded by"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-ana-sequential",
            "title": "Sequential Analysis"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [analysis](/records/reasoning/axis-analysis)",
                  "Math type: [graph](/records/reasoning/math-type-graph)",
                  "Concept: [relational](/records/reasoning/lens-relation)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "[Relational Graph Duplication](/records/algorithms/relational-graph-duplication)",
                    "term": "Grounded by"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-ana-relational",
            "title": "Relational Analysis"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [analysis](/records/reasoning/axis-analysis)",
                  "Math type: [dynamical-systems](/records/reasoning/math-type-dynamical-systems)",
                  "Concept: [behavioral](/records/reasoning/lens-behavior)"
                ],
                "kind": "list"
              },
              {
                "entries": [],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-ana-behavioral",
            "title": "Behavioral Analysis"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [analysis](/records/reasoning/axis-analysis)",
                  "Math type: [analysis](/records/reasoning/math-type-analysis)",
                  "Concept: [functional](/records/reasoning/lens-function)"
                ],
                "kind": "list"
              },
              {
                "entries": [],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-ana-functional",
            "title": "Functional Analysis"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [analysis](/records/reasoning/axis-analysis)",
                  "Math type: [logic](/records/reasoning/math-type-logic)",
                  "Concept: [semantic](/records/reasoning/lens-meaning)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "[Conceptual Duplication Detection](/records/algorithms/conceptual-duplication-detection)",
                    "term": "Grounded by"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-ana-semantic",
            "title": "Semantic Analysis"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [analysis](/records/reasoning/axis-analysis)",
                  "Math type: [analysis](/records/reasoning/math-type-analysis)",
                  "Concept: [causal](/records/reasoning/lens-cause)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "[Causal Wiring Duplication](/records/algorithms/causal-wiring-duplication)",
                    "term": "Grounded by"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-ana-causal",
            "title": "Causal Analysis"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [analysis](/records/reasoning/axis-analysis)",
                  "Math type: [probability](/records/reasoning/math-type-probability)",
                  "Concept: [predictive](/records/reasoning/lens-prediction)"
                ],
                "kind": "list"
              },
              {
                "entries": [],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-ana-predictive",
            "title": "Predictive Analysis"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [analysis](/records/reasoning/axis-analysis)",
                  "Math type: [probability](/records/reasoning/math-type-probability)",
                  "Concept: [anomaly](/records/reasoning/lens-anomaly)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "[Anomaly Outlier Detection](/records/algorithms/anomaly-outlier-detection)",
                    "term": "Grounded by"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-ana-anomaly",
            "title": "Anomaly Analysis"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [analysis](/records/reasoning/axis-analysis)",
                  "Math type: [dynamical-systems](/records/reasoning/math-type-dynamical-systems)",
                  "Concept: [evolutionary](/records/reasoning/lens-change)"
                ],
                "kind": "list"
              },
              {
                "entries": [],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-ana-evolutionary",
            "title": "Evolutionary Analysis"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [analysis](/records/reasoning/axis-analysis)",
                  "Math type: [topology](/records/reasoning/math-type-topology)",
                  "Concept: [fractal](/records/reasoning/lens-fractal)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "[Fractal Scale Duplication](/records/algorithms/fractal-scale-duplication)",
                    "term": "Grounded by"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-ana-fractal",
            "title": "Fractal Analysis"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [reasoning](/records/reasoning/axis-reasoning)",
                  "Math type: [set-theory](/records/reasoning/math-type-set-theory)",
                  "Concept: [observation](/records/reasoning/mode-observation)"
                ],
                "kind": "list"
              },
              {
                "entries": [],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-rea-observation",
            "title": "Observation"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [reasoning](/records/reasoning/axis-reasoning)",
                  "Math type: [logic](/records/reasoning/math-type-logic)",
                  "Concept: [description](/records/reasoning/mode-description)"
                ],
                "kind": "list"
              },
              {
                "entries": [],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-rea-description",
            "title": "Description"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [reasoning](/records/reasoning/axis-reasoning)",
                  "Math type: [logic](/records/reasoning/math-type-logic)",
                  "Concept: [comparison](/records/reasoning/mode-comparison)"
                ],
                "kind": "list"
              },
              {
                "entries": [],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-rea-comparison",
            "title": "Comparison"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [reasoning](/records/reasoning/axis-reasoning)",
                  "Math type: [set-theory](/records/reasoning/math-type-set-theory)",
                  "Concept: [classification](/records/reasoning/mode-classification)"
                ],
                "kind": "list"
              },
              {
                "entries": [],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-rea-classification",
            "title": "Classification"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [reasoning](/records/reasoning/axis-reasoning)",
                  "Math type: [analysis](/records/reasoning/math-type-analysis)",
                  "Concept: [explanation](/records/reasoning/mode-explanation)"
                ],
                "kind": "list"
              },
              {
                "entries": [],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-rea-explanation",
            "title": "Explanation"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [reasoning](/records/reasoning/axis-reasoning)",
                  "Math type: [probability](/records/reasoning/math-type-probability)",
                  "Concept: [prediction](/records/reasoning/mode-prediction)"
                ],
                "kind": "list"
              },
              {
                "entries": [],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-rea-prediction",
            "title": "Prediction"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [reasoning](/records/reasoning/axis-reasoning)",
                  "Math type: [analysis](/records/reasoning/math-type-analysis)",
                  "Concept: [intervention](/records/reasoning/mode-intervention)"
                ],
                "kind": "list"
              },
              {
                "entries": [],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-rea-intervention",
            "title": "Intervention"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [reasoning](/records/reasoning/axis-reasoning)",
                  "Math type: [computation](/records/reasoning/math-type-computation)",
                  "Concept: [creation](/records/reasoning/mode-creation)"
                ],
                "kind": "list"
              },
              {
                "entries": [],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-rea-creation",
            "title": "Creation"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [reasoning](/records/reasoning/axis-reasoning)",
                  "Math type: [topology](/records/reasoning/math-type-topology)",
                  "Concept: [reflection](/records/reasoning/mode-reflection)"
                ],
                "kind": "list"
              },
              {
                "entries": [],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-rea-reflection",
            "title": "Reflection"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [representation](/records/reasoning/axis-representation)",
                  "Math type: [algebra](/records/reasoning/math-type-algebra)",
                  "Concept: [symbolic](/records/reasoning/representation-symbolic)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Is it encoded as equations or notation?",
                    "term": "Question"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-rep-symbolic",
            "title": "Symbolic Representation"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [representation](/records/reasoning/axis-representation)",
                  "Math type: [probability](/records/reasoning/math-type-probability)",
                  "Concept: [numerical](/records/reasoning/representation-number)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Is it encoded as quantities?",
                    "term": "Question"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-rep-numerical",
            "title": "Numerical Representation"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [representation](/records/reasoning/axis-representation)",
                  "Math type: [topology](/records/reasoning/math-type-topology)",
                  "Concept: [geometric](/records/reasoning/representation-geometry)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Is it encoded as shapes or coordinates?",
                    "term": "Question"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-rep-geometric",
            "title": "Geometric Representation"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [representation](/records/reasoning/axis-representation)",
                  "Math type: [topology](/records/reasoning/math-type-topology)",
                  "Concept: [topological](/records/reasoning/representation-topology)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Is it encoded as connectivity or continuity?",
                    "term": "Question"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-rep-topological",
            "title": "Topological Representation"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [representation](/records/reasoning/axis-representation)",
                  "Math type: [information-theory](/records/reasoning/math-type-information-theory)",
                  "Concept: [information-theoretic](/records/reasoning/representation-information-theory)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Is it encoded as entropy or compression?",
                    "term": "Question"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-rep-information-theoretic",
            "title": "Information-Theoretic Representation"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [representation](/records/reasoning/axis-representation)",
                  "Math type: [probability](/records/reasoning/math-type-probability)",
                  "Concept: [probabilistic](/records/reasoning/representation-probability)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Is it encoded as distributions?",
                    "term": "Question"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-rep-probabilistic",
            "title": "Probabilistic Representation"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [representation](/records/reasoning/axis-representation)",
                  "Math type: [dynamical-systems](/records/reasoning/math-type-dynamical-systems)",
                  "Concept: [dynamical](/records/reasoning/representation-dynamical-systems)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Is it encoded as state transitions?",
                    "term": "Question"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-rep-dynamical",
            "title": "Dynamical Representation"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [representation](/records/reasoning/axis-representation)",
                  "Math type: [computation](/records/reasoning/math-type-computation)",
                  "Concept: [computational](/records/reasoning/representation-computation)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Is it encoded as an algorithm?",
                    "term": "Question"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-rep-computational",
            "title": "Computational Representation"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [formalization](/records/reasoning/axis-formalization)",
                  "Math type: [set-theory](/records/reasoning/math-type-set-theory)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "What object exists?",
                    "term": "Question"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-for-existence",
            "title": "Existence"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [formalization](/records/reasoning/axis-formalization)",
                  "Math type: [algebra](/records/reasoning/math-type-algebra)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "What structure holds?",
                    "term": "Question"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-for-structure",
            "title": "Formal Structure"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [formalization](/records/reasoning/axis-formalization)",
                  "Math type: [graph](/records/reasoning/math-type-graph)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "What mapping connects objects?",
                    "term": "Question"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-for-relation",
            "title": "Mapping"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [formalization](/records/reasoning/axis-formalization)",
                  "Math type: [topology](/records/reasoning/math-type-topology)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "What environment contains them?",
                    "term": "Question"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-for-space",
            "title": "Environment"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [formalization](/records/reasoning/axis-formalization)",
                  "Math type: [analysis](/records/reasoning/math-type-analysis)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "What operation applies?",
                    "term": "Question"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-for-transformation",
            "title": "Transformation"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [formalization](/records/reasoning/axis-formalization)",
                  "Math type: [topology](/records/reasoning/math-type-topology)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "What is preserved?",
                    "term": "Question"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-for-invariance",
            "title": "Invariance"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [formalization](/records/reasoning/axis-formalization)",
                  "Math type: [probability](/records/reasoning/math-type-probability)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "What is uncertain?",
                    "term": "Question"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-for-uncertainty",
            "title": "Uncertainty"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [formalization](/records/reasoning/axis-formalization)",
                  "Math type: [computation](/records/reasoning/math-type-computation)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "What is computable?",
                    "term": "Question"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-for-computation",
            "title": "Computability"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [formalization](/records/reasoning/axis-formalization)",
                  "Math type: [topology](/records/reasoning/math-type-topology)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "What generalizes?",
                    "term": "Question"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-for-abstraction",
            "title": "Abstraction"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [formalization](/records/reasoning/axis-formalization)",
                  "Math type: [computation](/records/reasoning/math-type-computation)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "What new structure can emerge?",
                    "term": "Question"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-for-creation",
            "title": "Emergence"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [formalization](/records/reasoning/axis-formalization)",
                  "Math type: [set-theory](/records/reasoning/math-type-set-theory)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "What is absent, and is it distinguished from unknown, omitted and zero?",
                    "term": "Question"
                  },
                  {
                    "description": "set",
                    "term": "Answer shape"
                  },
                  {
                    "description": "every absence a later check must distinguish is represented as its own value",
                    "term": "Decision test"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-for-absence",
            "title": "Absence"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [teleology](/records/reasoning/axis-teleology)",
                  "Math type: [optimization](/records/reasoning/math-type-optimization)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "What is the objective?",
                    "term": "Question"
                  },
                  {
                    "description": "[meta_block](/records/pag/production-meta-block), [meta_field](/records/pag/production-meta-field), [node_meta_tag](/records/pag/production-node-meta-tag)",
                    "term": "Grounded by"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-tel-objective",
            "title": "Objective"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [teleology](/records/reasoning/axis-teleology)",
                  "Math type: [optimization](/records/reasoning/math-type-optimization)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "How much does this advance the objective?",
                    "term": "Question"
                  },
                  {
                    "description": "number",
                    "term": "Answer shape"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-tel-utility",
            "title": "Branch Utility"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [teleology](/records/reasoning/axis-teleology)",
                  "Math type: [optimization](/records/reasoning/math-type-optimization)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "What does this cost?",
                    "term": "Question"
                  },
                  {
                    "description": "number",
                    "term": "Answer shape"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-tel-cost",
            "title": "Branch Cost"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [teleology](/records/reasoning/axis-teleology)",
                  "Math type: [optimization](/records/reasoning/math-type-optimization)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Is this the highest-worth admissible branch?",
                    "term": "Question"
                  },
                  {
                    "description": "boolean",
                    "term": "Answer shape"
                  },
                  {
                    "description": "the branch has the highest utility minus cost among the admissible branches",
                    "term": "Decision test"
                  },
                  {
                    "description": "injection-gate",
                    "term": "Role"
                  },
                  {
                    "description": "[Adaptive Phase Boundary](/records/algorithms/adaptive-phase-boundary), [Automation Priority Ordering](/records/algorithms/automation-priority-ordering), [Developer Decision Gate](/records/algorithms/developer-decision-gate), [Teleological Intent Gate](/records/algorithms/teleological-intent-gate), [Severity Assignment](/records/algorithms/severity-assignment), [Severity Failure Routing](/records/algorithms/severity-failure-routing), [Severity-Ordered Remediation](/records/algorithms/severity-ordered-remediation), [Coverage Risk Prioritization](/records/algorithms/coverage-risk-prioritization), [Anti-Pattern Priority Matrix](/records/algorithms/anti-pattern-priority-matrix), [Reshape Risk Priority](/records/algorithms/reshape-risk-priority), [Vocabulary Admission Gate](/records/algorithms/vocabulary-admission-gate), [priority_queue_declaration](/records/pag/production-priority-queue-declaration)",
                    "term": "Grounded by"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-tel-priority",
            "title": "Branch Priority"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [verification](/records/reasoning/axis-verification)",
                  "Math type: [set-theory](/records/reasoning/math-type-set-theory)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "What evidence supports this?",
                    "term": "Question"
                  },
                  {
                    "description": "set",
                    "term": "Answer shape"
                  },
                  {
                    "description": "the evidence set is non-empty",
                    "term": "Decision test"
                  },
                  {
                    "description": "both",
                    "term": "Role"
                  },
                  {
                    "description": "[semantic-correctness](/records/reasoning/test-surface-semantic-correctness), [functional-correctness](/records/reasoning/test-surface-functional-correctness), [state-correctness](/records/reasoning/test-surface-state-correctness), [interface-correctness](/records/reasoning/test-surface-interface-correctness), [interaction-correctness](/records/reasoning/test-surface-interaction-correctness), [temporal-correctness](/records/reasoning/test-surface-temporal-correctness), [concurrency-correctness](/records/reasoning/test-surface-concurrency-correctness), [memory-correctness](/records/reasoning/test-surface-memory-correctness), [resource-correctness](/records/reasoning/test-surface-resource-correctness), [performance-correctness](/records/reasoning/test-surface-performance-correctness), [reliability-correctness](/records/reasoning/test-surface-reliability-correctness), [availability-correctness](/records/reasoning/test-surface-availability-correctness), [consistency-correctness](/records/reasoning/test-surface-consistency-correctness), [data-correctness](/records/reasoning/test-surface-data-correctness), [numerical-correctness](/records/reasoning/test-surface-numerical-correctness), [security-correctness](/records/reasoning/test-surface-security-correctness), [determinism-correctness](/records/reasoning/test-surface-determinism-correctness), [protocol-correctness](/records/reasoning/test-surface-protocol-correctness), [configuration-correctness](/records/reasoning/test-surface-configuration-correctness), [observability-correctness](/records/reasoning/test-surface-observability-correctness), [Evidence Grounding Validation](/records/algorithms/evidence-grounding-validation), [Workflow Validation Gate](/records/algorithms/workflow-validation-gate), [Additive Debt Gate](/records/algorithms/additive-debt-gate), [Zero-Duplication Verification](/records/algorithms/zero-duplication-verification), [Evidence-Based Claim Verification](/records/algorithms/evidence-based-claim-verification), [Verification Execution](/records/algorithms/verification-execution), [Reverification Gate](/records/algorithms/reverification-gate), [Evidence-Gated Claim Verification](/records/algorithms/evidence-gated-claim-verification), [Environment Capability Verification](/records/algorithms/environment-capability-verification), [Recursive Self-Verification](/records/algorithms/recursive-self-verification), [Evidence Verdict](/records/algorithms/evidence-verdict), [PAG Handoff Gate](/records/algorithms/pag-validation-gate), [Anti-Pattern Elimination Verification](/records/algorithms/anti-pattern-elimination-verification), [Plan Phase Verification](/records/algorithms/plan-phase-verification), [Machine Verdict Derivation](/records/algorithms/machine-verdict-derivation), [Mode Contract Validation](/records/algorithms/mode-contract-validation), [Discovery Verification](/records/algorithms/discovery-verification), [handoff_gate](/records/pag/production-handoff-gate), [check_line](/records/pag/production-check-line), [check_marker](/records/pag/production-check-marker), [report_block](/records/pag/production-report-block)",
                    "term": "Grounded by"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-ver-evidence",
            "title": "Evidence"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [verification](/records/reasoning/axis-verification)",
                  "Math type: [logic](/records/reasoning/math-type-logic)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Is it true against reality, not merely coherent?",
                    "term": "Question"
                  },
                  {
                    "description": "[semantic-correctness](/records/reasoning/test-surface-semantic-correctness), [functional-correctness](/records/reasoning/test-surface-functional-correctness), [state-correctness](/records/reasoning/test-surface-state-correctness), [interface-correctness](/records/reasoning/test-surface-interface-correctness), [interaction-correctness](/records/reasoning/test-surface-interaction-correctness), [temporal-correctness](/records/reasoning/test-surface-temporal-correctness), [concurrency-correctness](/records/reasoning/test-surface-concurrency-correctness), [memory-correctness](/records/reasoning/test-surface-memory-correctness), [resource-correctness](/records/reasoning/test-surface-resource-correctness), [performance-correctness](/records/reasoning/test-surface-performance-correctness), [reliability-correctness](/records/reasoning/test-surface-reliability-correctness), [availability-correctness](/records/reasoning/test-surface-availability-correctness), [consistency-correctness](/records/reasoning/test-surface-consistency-correctness), [data-correctness](/records/reasoning/test-surface-data-correctness), [numerical-correctness](/records/reasoning/test-surface-numerical-correctness), [security-correctness](/records/reasoning/test-surface-security-correctness), [determinism-correctness](/records/reasoning/test-surface-determinism-correctness), [protocol-correctness](/records/reasoning/test-surface-protocol-correctness), [configuration-correctness](/records/reasoning/test-surface-configuration-correctness), [observability-correctness](/records/reasoning/test-surface-observability-correctness)",
                    "term": "Grounded by"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-ver-ground-truth",
            "title": "Ground Truth"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [verification](/records/reasoning/axis-verification)",
                  "Math type: [logic](/records/reasoning/math-type-logic)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "What would refute it?",
                    "term": "Question"
                  },
                  {
                    "description": "[invariant_record](/records/pag/production-invariant-record)",
                    "term": "Grounded by"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-ver-falsification",
            "title": "Refutation Condition"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [verification](/records/reasoning/axis-verification)",
                  "Math type: [probability](/records/reasoning/math-type-probability)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "How confident is it, and is that enough?",
                    "term": "Question"
                  },
                  {
                    "description": "number[0,1]",
                    "term": "Answer shape"
                  },
                  {
                    "description": "confidence is at or above the threshold",
                    "term": "Decision test"
                  },
                  {
                    "description": "[verdict](/records/pag/production-verdict)",
                    "term": "Grounded by"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-ver-confidence",
            "title": "Confidence"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [verification](/records/reasoning/axis-verification)",
                  "Math type: [logic](/records/reasoning/math-type-logic)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Does refutation outweigh support?",
                    "term": "Question"
                  },
                  {
                    "description": "[result_line](/records/pag/production-result-line), [repair_edge](/records/pag/production-repair-edge)",
                    "term": "Grounded by"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-ver-refutation",
            "title": "Support Against Refutation"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [verification](/records/reasoning/axis-verification)",
                  "Math type: [set-theory](/records/reasoning/math-type-set-theory)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Over what set was this checked?",
                    "term": "Question"
                  },
                  {
                    "description": "ratio",
                    "term": "Answer shape"
                  },
                  {
                    "description": "the declared population is non-empty and every member is measured or named absent",
                    "term": "Decision test"
                  },
                  {
                    "description": "both",
                    "term": "Role"
                  },
                  {
                    "description": "[PAG Handoff Gate](/records/algorithms/pag-validation-gate), [population_clause](/records/pag/production-population-clause), [report_field](/records/pag/production-report-field)",
                    "term": "Grounded by"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-ver-population",
            "title": "Population"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [verification](/records/reasoning/axis-verification)",
                  "Math type: [information-theory](/records/reasoning/math-type-information-theory)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Was the read derived after the last relevant mutator?",
                    "term": "Question"
                  },
                  {
                    "description": "boolean",
                    "term": "Answer shape"
                  },
                  {
                    "description": "the fingerprint of the inputs and the code matches the output's declared derivation",
                    "term": "Decision test"
                  },
                  {
                    "description": "[freshness_clause](/records/pag/production-freshness-clause), [report_field](/records/pag/production-report-field)",
                    "term": "Grounded by"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-ver-freshness",
            "title": "Freshness"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [verification](/records/reasoning/axis-verification)",
                  "Math type: [logic](/records/reasoning/math-type-logic)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Did the read set move beneath the verdict?",
                    "term": "Question"
                  },
                  {
                    "description": "boolean",
                    "term": "Answer shape"
                  },
                  {
                    "description": "the moved set is empty",
                    "term": "Decision test"
                  },
                  {
                    "description": "[PAG Handoff Gate](/records/algorithms/pag-validation-gate), [standing_line](/records/pag/production-standing-line)",
                    "term": "Grounded by"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-ver-standing",
            "title": "Standing"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [verification](/records/reasoning/axis-verification)",
                  "Math type: [set-theory](/records/reasoning/math-type-set-theory)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Where does this stage refuse to continue?",
                    "term": "Question"
                  },
                  {
                    "description": "set",
                    "term": "Answer shape"
                  },
                  {
                    "description": "a refusal condition is named before the irreversible write",
                    "term": "Decision test"
                  },
                  {
                    "description": "injection-gate",
                    "term": "Role"
                  },
                  {
                    "description": "[PAG Handoff Gate](/records/algorithms/pag-validation-gate), [refusal_line](/records/pag/production-refusal-line)",
                    "term": "Grounded by"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-ver-refusal",
            "title": "Refusal"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [verification](/records/reasoning/axis-verification)",
                  "Math type: [set-theory](/records/reasoning/math-type-set-theory)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Does the observation locate a failure, or is an absence of failures read as proof?",
                    "term": "Question"
                  },
                  {
                    "description": "set",
                    "term": "Answer shape"
                  },
                  {
                    "description": "every observed location is reported as located, and no observed absence is reported as verified",
                    "term": "Decision test"
                  },
                  {
                    "description": "[report_field](/records/pag/production-report-field)",
                    "term": "Grounded by"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-ver-observation",
            "title": "Located Observation"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [termination](/records/reasoning/axis-termination)",
                  "Math type: [set-theory](/records/reasoning/math-type-set-theory)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Is every task done?",
                    "term": "Question"
                  },
                  {
                    "description": "boolean",
                    "term": "Answer shape"
                  },
                  {
                    "description": "every task is done",
                    "term": "Decision test"
                  },
                  {
                    "description": "completion-marker",
                    "term": "Role"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-ter-completion",
            "title": "Completion"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [termination](/records/reasoning/axis-termination)",
                  "Math type: [set-theory](/records/reasoning/math-type-set-theory)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Is nothing left to resolve?",
                    "term": "Question"
                  },
                  {
                    "description": "boolean",
                    "term": "Answer shape"
                  },
                  {
                    "description": "no open items remain",
                    "term": "Decision test"
                  },
                  {
                    "description": "both",
                    "term": "Role"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-ter-saturation",
            "title": "Saturation"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [termination](/records/reasoning/axis-termination)",
                  "Math type: [dynamical-systems](/records/reasoning/math-type-dynamical-systems)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Has progress stopped increasing?",
                    "term": "Question"
                  },
                  {
                    "description": "counter",
                    "term": "Answer shape"
                  },
                  {
                    "description": "progress is unchanged across a bounded window",
                    "term": "Decision test"
                  },
                  {
                    "description": "injection-gate",
                    "term": "Role"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-ter-diminishing-returns",
            "title": "Diminishing Returns"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [termination](/records/reasoning/axis-termination)",
                  "Math type: [logic](/records/reasoning/math-type-logic)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Is it blocked on external input?",
                    "term": "Question"
                  },
                  {
                    "description": "boolean",
                    "term": "Answer shape"
                  },
                  {
                    "description": "[PAG Handoff Gate](/records/algorithms/pag-validation-gate), [result_line](/records/pag/production-result-line), [wait_statement](/records/pag/production-wait-statement)",
                    "term": "Grounded by"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-ter-block",
            "title": "Blocked Run"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [termination](/records/reasoning/axis-termination)",
                  "Math type: [optimization](/records/reasoning/math-type-optimization)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Do saturation, completion and verification all hold, or is the run blocked?",
                    "term": "Question"
                  },
                  {
                    "description": "boolean",
                    "term": "Answer shape"
                  },
                  {
                    "description": "saturation, completion and verification all hold, or ter-block holds",
                    "term": "Decision test"
                  },
                  {
                    "description": "completion-marker",
                    "term": "Role"
                  },
                  {
                    "description": "[Agent Generation Completion](/records/algorithms/agent-generation-completion), [First-Time Initiation](/records/algorithms/first-time-initiation), [Automation Completion Status](/records/algorithms/automation-completion-status), [Completion Truthfulness](/records/algorithms/completion-truthfulness), [Explicit Termination](/records/algorithms/explicit-termination), [Iteration Bound](/records/algorithms/iteration-bound), [Validation Gate](/records/algorithms/validation-gate), [Coverage Completion](/records/algorithms/coverage-completion), [Pattern Distillation Completion Truthfulness](/records/algorithms/pattern-distillation-completion-truthfulness), [Phase Close Gate](/records/algorithms/phase-close-gate), [Bounded Cascade Termination](/records/algorithms/bounded-cascade-termination), [Taxonomy Completion](/records/algorithms/taxonomy-completion), [report_field](/records/pag/production-report-field)",
                    "term": "Grounded by"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-ter-stop",
            "title": "Stop Condition"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [termination](/records/reasoning/axis-termination)",
                  "Math type: [set-theory](/records/reasoning/math-type-set-theory)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Is the candidate promoted, or only produced?",
                    "term": "Question"
                  },
                  {
                    "description": "boolean",
                    "term": "Answer shape"
                  },
                  {
                    "description": "a clean verdict precedes the move into accepted state",
                    "term": "Decision test"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-ter-promotion",
            "title": "Promotion"
          },
          {
            "blocks": [
              {
                "items": [
                  "Axis: [termination](/records/reasoning/axis-termination)",
                  "Math type: [logic](/records/reasoning/math-type-logic)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Is the boundary to the external system explicit, and who crosses it?",
                    "term": "Question"
                  },
                  {
                    "description": "boolean",
                    "term": "Answer shape"
                  },
                  {
                    "description": "the publication gate names its party",
                    "term": "Decision test"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the structured-document validator, which requires the gate clause each node grounds wherever a document writes, reads, stops or reports",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every structured document whose constructs ground the node",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the document, the grammar or the node changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The validator fails a gate that omits the clause the node asks for",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a node is a question a gate asks; the answer comes from the check the gate runs",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a check with no evidence, a gate with no population, a write with no refusal and a node with no gate, and validates a well-formed document clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The gate clause the node asks for, which every document's gate conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-node-ter-publication",
            "title": "Publication"
          }
        ],
        "title": "The nodes"
      },
      {
        "icon": "bi-signpost-split",
        "id": "the-mathematics",
        "intro": "The predicates are typed by these math types, each listed with its contracts and the domains of mathematics it draws on.",
        "subsections": [
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "What members exist?",
                    "term": "Question"
                  },
                  {
                    "description": "[set-theory](/records/reasoning/math-domain-set-theory)",
                    "term": "Fields"
                  },
                  {
                    "description": "membership · cardinality · emptiness",
                    "term": "Predicate family"
                  },
                  {
                    "description": "set | boolean | ratio",
                    "term": "Yields shape"
                  },
                  {
                    "description": "[Evidence-Before-Generation](/records/algorithms/evidence-before-generation), [Capability Profile](/records/algorithms/capability-profile), [Scope Extraction](/records/algorithms/scope-extraction), [Domain Knowledge Base](/records/algorithms/domain-knowledge-base), [Existing Pattern Extraction](/records/algorithms/existing-pattern-extraction), [DSL Compliance Loading](/records/algorithms/dsl-compliance-loading), [Workspace Configuration Discovery](/records/algorithms/workspace-configuration-discovery), [Smell Taxonomy](/records/algorithms/smell-taxonomy), [Responsibility Boundary](/records/algorithms/responsibility-boundary), [Canonical Data](/records/algorithms/canonical-data), [Self-Description Manifest](/records/algorithms/self-description-manifest), [Runtime Discovery](/records/algorithms/runtime-discovery), [Canonical Semantics](/records/algorithms/canonical-semantics), [Self-Description and Discovery](/records/algorithms/self-description-and-discovery), [Concept Cluster Extraction](/records/algorithms/concept-cluster-extraction), [Capability Degradation](/records/algorithms/capability-degradation), [Automation Opportunity Detection](/records/algorithms/automation-opportunity-detection), [Capability Disclosure](/records/algorithms/capability-disclosure), [Detection Registry](/records/algorithms/detection-registry), [Orientation Stage](/records/algorithms/orientation-stage), [Authoritative Source Loading](/records/algorithms/authoritative-source-loading), [Skeptical Context Acquisition](/records/algorithms/skeptical-context-acquisition), [Explicit Termination](/records/algorithms/explicit-termination), [Context Initialization](/records/algorithms/context-initialization), [Early Success Exit](/records/algorithms/early-success-exit), [Trust Anchor Declaration](/records/algorithms/trust-anchor-declaration), [Duplicate Disposition Walk](/records/algorithms/duplicate-disposition-walk), [Lifetime Resolution](/records/algorithms/lifetime-resolution), [Coverage Workspace](/records/algorithms/coverage-workspace), [Surface Grid Walk](/records/algorithms/surface-grid-walk), [PAG Document Declaration](/records/algorithms/pag-document-declaration), [PAG Keyword Ontology](/records/algorithms/pag-keyword-ontology), [Analysis Workspace](/records/algorithms/analysis-workspace), [Registry Baseline](/records/algorithms/registry-baseline), [Semantic Domain Partitioning](/records/algorithms/semantic-domain-partitioning), [Cross-Class Pattern Detection](/records/algorithms/cross-class-pattern-detection), [Temporal Coupling Detection](/records/algorithms/temporal-coupling-detection), [Profile Compose](/records/algorithms/profile-compose), [Seed Composition](/records/algorithms/seed-composition), [Token Source-of-Truth](/records/algorithms/token-source-of-truth), [Custom Type Registration](/records/algorithms/custom-type-registration), [Taxonomy Jurisdiction](/records/algorithms/taxonomy-jurisdiction)",
                    "term": "Contracts"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the yields check, which holds every algorithm's yields and every node's answer shape within the math type's shapes, the ontology resolution gate over every record that names the math type",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every algorithm record, node, axis and substrate node that names the math type",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the math type's shapes or a record that names it changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a yield or answer shape outside the type's shapes, or a reference to a type that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a math type is a family of answers, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a node with a dangling math type, another plants an answer shape outside the type's shapes, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The math type's shapes, which every yield and answer shape conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-math-type-set-theory",
            "title": "set-theory"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "Does it hold, and what follows from it?",
                    "term": "Question"
                  },
                  {
                    "description": "[logic](/records/reasoning/math-domain-logic)",
                    "term": "Fields"
                  },
                  {
                    "description": "boolean predicate",
                    "term": "Predicate family"
                  },
                  {
                    "description": "boolean",
                    "term": "Yields shape"
                  },
                  {
                    "description": "[Semantic Operation Boundary](/records/algorithms/semantic-operation-boundary), [Domain Cache Validation](/records/algorithms/domain-cache-validation), [Principle Extraction](/records/algorithms/principle-extraction), [Phase Validation Requirement](/records/algorithms/phase-validation-requirement), [Validation Strategy Composition](/records/algorithms/validation-strategy-composition), [Semantic Compliance Validation](/records/algorithms/semantic-compliance-validation), [Algorithmic Embodiment Validation](/records/algorithms/algorithmic-embodiment-validation), [Agent Generation Completion](/records/algorithms/agent-generation-completion), [Hybrid Workflow Orchestration](/records/algorithms/hybrid-workflow-orchestration), [Context Forking Configuration](/records/algorithms/context-forking-configuration), [Verb-Based Execution Classification](/records/algorithms/verb-based-execution-classification), [Workflow Type Document Selection](/records/algorithms/workflow-type-document-selection), [Handoff Signal](/records/algorithms/handoff-signal), [Orchestrator Action](/records/algorithms/orchestrator-action), [Workflow Principles Mapping](/records/algorithms/workflow-principles-mapping), [Workflow Validation Gate](/records/algorithms/workflow-validation-gate), [Anti-Pattern Inversion](/records/algorithms/anti-pattern-inversion), [Architecture Smell Record](/records/algorithms/architecture-smell-record), [Document Truth Alignment](/records/algorithms/document-truth-alignment), [Interface Contract](/records/algorithms/interface-contract), [Substitutability](/records/algorithms/substitutability), [Extension Point](/records/algorithms/extension-point), [Behavioral Dispatch](/records/algorithms/behavioral-dispatch), [Port Adapter](/records/algorithms/port-adapter), [Transaction Boundary](/records/algorithms/transaction-boundary), [Idempotent Side Effect](/records/algorithms/idempotent-side-effect), [Deterministic Core](/records/algorithms/deterministic-core), [Error Boundary](/records/algorithms/error-boundary), [Cache Correctness](/records/algorithms/cache-correctness), [Security Policy](/records/algorithms/security-policy), [Control Plane](/records/algorithms/control-plane), [Universal Architectural Concern Template](/records/algorithms/universal-architectural-concern-template), [Consumer Config SSOT](/records/algorithms/consumer-config-ssot), [Architectural Force Classification](/records/algorithms/architectural-force-classification), [Conflict and Tension Resolution](/records/algorithms/conflict-and-tension-resolution), [Violation Detection](/records/algorithms/violation-detection), [Enforcement Gate](/records/algorithms/enforcement-gate), [Modular Boundary Compliance](/records/algorithms/modular-boundary-compliance), [Contract Compatibility](/records/algorithms/contract-compatibility), [Runtime Extensibility](/records/algorithms/runtime-extensibility), [Event and Messaging Consistency](/records/algorithms/event-and-messaging-consistency), [State and Transaction Safety](/records/algorithms/state-and-transaction-safety), [Correctness Verification](/records/algorithms/correctness-verification), [Resilience Policy](/records/algorithms/resilience-policy), [Security Governance](/records/algorithms/security-governance), [Control Plane Coordination](/records/algorithms/control-plane-coordination), [Metaprogramming Safety](/records/algorithms/metaprogramming-safety), [Model Lifecycle Governance](/records/algorithms/model-lifecycle-governance), [Relationship Schema Validation](/records/algorithms/relationship-schema-validation), [Constraints Over Shortcuts](/records/algorithms/no-shortcuts), [Forward Compatibility Over Backward Compatibility](/records/algorithms/no-backward-compat), [Fail-Fast Over Fallback](/records/algorithms/no-fallback), [Explicit Removal Over Deprecation](/records/algorithms/no-deprecation), [Greenfield Over Legacy](/records/algorithms/no-legacy), [Single-Path Determinism Over Dual-Path](/records/algorithms/no-dual-path), [Immediacy Over Deferring](/records/algorithms/no-deferring), [Mandatory Over Optional](/records/algorithms/no-optional), [Now Over For-Now](/records/algorithms/no-for-now), [Observed Execution Over Unobserved](/records/algorithms/no-unobserved), [Compression Over Repetition](/records/algorithms/no-uncompressed), [Approved Evolution Over Unapproved](/records/algorithms/no-unapproved), [Enforced Feedback Over Ignored](/records/algorithms/no-ignored-feedback), [Single Owner Over Shared Ownership](/records/algorithms/no-shared-ownership), [Bounded Lifetime Over Unbounded](/records/algorithms/no-unbounded), [Enforced Symmetry Over Asymmetric Lifecycle](/records/algorithms/no-asymmetric), [Explicit Retention Over Implicit](/records/algorithms/no-implicit-retention), [Structural Release Over Discipline](/records/algorithms/no-discipline-release), [Immutable Data Over Mutable State](/records/algorithms/no-mutable), [Errors As Language Over Silent Errors](/records/algorithms/no-silent), [Explicit Invalidity Over Hidden](/records/algorithms/no-hidden-invalidity), [Event Emission Over Parent Callbacks](/records/algorithms/no-callbacks), [Monotonic Growth Over Retraction](/records/algorithms/no-retraction), [Semantic Addressing Over Location Addressing](/records/algorithms/no-location), [Ordinal Time Over Timestamps](/records/algorithms/no-timestamps), [Homoiconicity Over Separation](/records/algorithms/no-separation), [Bounded Complexity Over Unlimited](/records/algorithms/no-unlimited), [Computed Health Over Metric Health](/records/algorithms/no-metrics), [Secret Store Over Hardcoded Secrets](/records/algorithms/no-hardcoded-secrets), [Boundary Validation Over Unvalidated Input](/records/algorithms/no-unvalidated-input), [Least Privilege Over Broad Privilege](/records/algorithms/no-broad-privilege), [Config Externalization Over Env Fallback](/records/algorithms/no-env-fallback), [Profile-First Over Unmeasured Optimization](/records/algorithms/no-unmeasured-optimization), [Rule As Code Over Convention](/records/algorithms/no-convention-enforcement), [Design By Contract Over Implicit Contract](/records/algorithms/no-implicit-contract), [Versioned Evolution Over Breaking Change](/records/algorithms/no-breaking-change), [Schema-Validated Boundary Over Untyped](/records/algorithms/no-untyped-boundary), [Atomic Boundary Over Partial Commit](/records/algorithms/no-partial-commit), [Saga Compensation Over Distributed 2PC](/records/algorithms/no-distributed-2pc), [Async Events Over Synchronous Cross-Boundary](/records/algorithms/no-sync-cross-boundary), [Observable Signals Over Opaque Runtime](/records/algorithms/no-opaque-runtime), [Injected Dependency Over Hidden](/records/algorithms/no-hidden-dependency), [Convention Discovery Over Hardcoded Wiring](/records/algorithms/no-hardcoded-wiring), [Declarative Config Over Imperative](/records/algorithms/no-imperative-config), [Anti-Corruption Layer Over Cross-Context Leak](/records/algorithms/no-leaky-context), [Injected Nondeterminism Over Hidden](/records/algorithms/no-hidden-nondeterminism), [Pattern By Fit Over Speculative Pattern](/records/algorithms/no-speculative-pattern), [Runtime-Neutral Automation Boundary](/records/algorithms/runtime-neutral-automation-boundary), [Intentional Static Separation](/records/algorithms/intentional-static-separation), [Extension Interface Discovery](/records/algorithms/extension-interface-discovery), [Performance-Aware Discovery Design](/records/algorithms/performance-aware-discovery-design), [Dynamic Extension Architecture](/records/algorithms/dynamic-extension-architecture), [Cache Invalidation Strategy](/records/algorithms/cache-invalidation-strategy), [Dynamic Failure Isolation](/records/algorithms/dynamic-failure-isolation), [Measured-vs-Estimated Validation](/records/algorithms/measured-vs-estimated-validation), [Architecture Validation Before Persistence](/records/algorithms/architecture-validation-before-persistence), [Automation Completion Status](/records/algorithms/automation-completion-status), [Runtime-Agnostic Adapter Boundary](/records/algorithms/runtime-agnostic-adapter-boundary), [Pattern Classification](/records/algorithms/pattern-classification), [Refactor Intent Classification](/records/algorithms/refactor-intent-classification), [Architecture Compliance Targeting](/records/algorithms/architecture-compliance-targeting), [Existing Solution Conflict](/records/algorithms/existing-solution-conflict), [Additive Debt Gate](/records/algorithms/additive-debt-gate), [Pattern-Specific Validation](/records/algorithms/pattern-specific-validation), [Zero-Duplication Verification](/records/algorithms/zero-duplication-verification), [Completion Truthfulness](/records/algorithms/completion-truthfulness), [Trust Anchor](/records/algorithms/trust-anchor), [Intent & Directionality Normalization](/records/algorithms/intent-directionality-normalization), [Planning Stage](/records/algorithms/planning-stage), [Principle Activation](/records/algorithms/principle-activation), [Protocol Semantic Selection](/records/algorithms/protocol-semantic-selection), [Loop Class Labeling](/records/algorithms/loop-class-labeling), [Codebase Pattern Enforcement](/records/algorithms/codebase-pattern-enforcement), [Validator Coverage](/records/algorithms/validator-coverage), [Structured Observability Context](/records/algorithms/structured-observability-context), [Cross-Cutting Surface Coverage](/records/algorithms/cross-cutting-surface-coverage), [Legacy Elimination](/records/algorithms/legacy-elimination), [Validation Stage](/records/algorithms/validation-stage), [Semantic Debt Policy](/records/algorithms/semantic-debt-policy), [Evidence-Based Claim Verification](/records/algorithms/evidence-based-claim-verification), [Validation Suite Battery](/records/algorithms/validation-suite-battery), [Verification Execution](/records/algorithms/verification-execution), [Violation Classification](/records/algorithms/violation-classification), [Reverification Gate](/records/algorithms/reverification-gate), [Evidence-Gated Claim Verification](/records/algorithms/evidence-gated-claim-verification), [Environment Capability Verification](/records/algorithms/environment-capability-verification), [Behavioral Self-Test](/records/algorithms/behavioral-self-test), [Adversarial Input Testing](/records/algorithms/adversarial-input-testing), [Safe Arithmetic Contract](/records/algorithms/safe-arithmetic-contract), [Invocation Join](/records/algorithms/invocation-join), [Uncovered Gap Derivation](/records/algorithms/uncovered-gap-derivation), [Evidence Verdict](/records/algorithms/evidence-verdict), [Coverage Completion](/records/algorithms/coverage-completion), [PAG Handoff Gate](/records/algorithms/pag-validation-gate), [PAG Explicit Control Flow](/records/algorithms/pag-explicit-control-flow), [PAG Ambiguity Reduction](/records/algorithms/pag-ambiguity-reduction), [PAG Well-Formedness Validation](/records/algorithms/pag-well-formedness-validation), [Anti-Pattern Classification](/records/algorithms/anti-pattern-classification), [Abstraction Boundary Principle](/records/algorithms/abstraction-boundary-principle), [Base-Class Candidate Selection](/records/algorithms/base-class-candidate-selection), [Anti-Pattern Elimination Verification](/records/algorithms/anti-pattern-elimination-verification), [Pattern Distillation Completion Truthfulness](/records/algorithms/pattern-distillation-completion-truthfulness), [Delta Capture](/records/algorithms/delta-capture), [Plan Phase Verification](/records/algorithms/plan-phase-verification), [Canonical Config Resolution](/records/algorithms/canonical-config-resolution), [Machine Verdict Derivation](/records/algorithms/machine-verdict-derivation), [Mode Contract Validation](/records/algorithms/mode-contract-validation), [Type-Keyed Appearance](/records/algorithms/type-keyed-appearance), [Concern Classification](/records/algorithms/concern-classification), [Discovery Verification](/records/algorithms/discovery-verification), [Taxonomy Completion](/records/algorithms/taxonomy-completion), [Container Ladder](/records/algorithms/container-ladder), [Export Triage Ladder](/records/algorithms/export-triage-ladder), [Alignment Cadence](/records/algorithms/alignment-cadence)",
                    "term": "Contracts"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the yields check, which holds every algorithm's yields and every node's answer shape within the math type's shapes, the ontology resolution gate over every record that names the math type",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every algorithm record, node, axis and substrate node that names the math type",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the math type's shapes or a record that names it changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a yield or answer shape outside the type's shapes, or a reference to a type that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a math type is a family of answers, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a node with a dangling math type, another plants an answer shape outside the type's shapes, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The math type's shapes, which every yield and answer shape conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-math-type-logic",
            "title": "logic"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "What connects what?",
                    "term": "Question"
                  },
                  {
                    "description": "[category-theory](/records/reasoning/math-domain-category-theory)",
                    "term": "Fields"
                  },
                  {
                    "description": "reachability · coverage · degree",
                    "term": "Predicate family"
                  },
                  {
                    "description": "edge-list",
                    "term": "Yields shape"
                  },
                  {
                    "description": "[Four-Dimensional Agent Graph](/records/algorithms/four-dimensional-agent-graph), [Anti-Pattern Relationship Record](/records/algorithms/anti-pattern-relationship-record), [Coupling Control](/records/algorithms/coupling-control), [Observability Trace](/records/algorithms/observability-trace), [Causality Ordering](/records/algorithms/causality-ordering), [Finite State Machine](/records/algorithms/finite-state-machine), [Statecharts](/records/algorithms/statecharts), [Petri Nets](/records/algorithms/petri-nets), [Architectural Relationship Record](/records/algorithms/architectural-relationship-record), [Architecture Knowledge Graph](/records/algorithms/architecture-knowledge-graph), [Dependency Closure](/records/algorithms/dependency-closure), [Reinforcement Propagation](/records/algorithms/reinforcement-propagation), [Observability and Auditability](/records/algorithms/observability-and-auditability), [Migration Action Mapping](/records/algorithms/migration-action-mapping), [Phase Decomposition](/records/algorithms/phase-decomposition), [Four-Dimensional Phase Graph](/records/algorithms/four-dimensional-phase-graph), [Dependency Linearization](/records/algorithms/dependency-linearization), [Ripple Chain Analysis](/records/algorithms/ripple-chain-analysis), [PAG Node Decomposition](/records/algorithms/pag-node-decomposition), [PAG Structure Declaration](/records/algorithms/pag-coordination-construct), [Relational Graph Duplication](/records/algorithms/relational-graph-duplication), [Causal Wiring Duplication](/records/algorithms/causal-wiring-duplication), [Stage Ordering](/records/algorithms/stage-ordering), [Path Role Walk](/records/algorithms/path-role-walk)",
                    "term": "Contracts"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the yields check, which holds every algorithm's yields and every node's answer shape within the math type's shapes, the ontology resolution gate over every record that names the math type",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every algorithm record, node, axis and substrate node that names the math type",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the math type's shapes or a record that names it changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a yield or answer shape outside the type's shapes, or a reference to a type that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a math type is a family of answers, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a node with a dangling math type, another plants an answer shape outside the type's shapes, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The math type's shapes, which every yield and answer shape conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-math-type-graph",
            "title": "graph"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "How are parts arranged under laws?",
                    "term": "Question"
                  },
                  {
                    "description": "[algebra](/records/reasoning/math-domain-algebra)",
                    "term": "Fields"
                  },
                  {
                    "description": "composition · ordering invariant",
                    "term": "Predicate family"
                  },
                  {
                    "description": "ordered-structure",
                    "term": "Yields shape"
                  },
                  {
                    "description": "[Agent Sequence Definition](/records/algorithms/agent-sequence-definition), [Anti-Pattern Remediation Algebra](/records/algorithms/anti-pattern-remediation-algebra), [Structural Mediation](/records/algorithms/structural-mediation), [Architecture Refactoring Roadmap](/records/algorithms/architecture-refactoring-roadmap), [Atomic Refactor Phase](/records/algorithms/atomic-refactor-phase), [Hierarchical Numbering](/records/algorithms/hierarchical-numbering), [Technique and Invariant Selection](/records/algorithms/technique-invariant-selection), [Sequential Chain Duplication](/records/algorithms/sequential-chain-duplication), [Concrete-vs-Abstract Responsibility Split](/records/algorithms/concrete-vs-abstract-responsibility-split), [Template Method Lifecycle](/records/algorithms/template-method-lifecycle), [Migration Ordering](/records/algorithms/migration-ordering), [Cascade Layer Partition](/records/algorithms/cascade-layer-partition), [Assembly Composition](/records/algorithms/assembly-composition), [Name Projection](/records/algorithms/name-projection), [Dialect Resolution](/records/algorithms/dialect-resolution)",
                    "term": "Contracts"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the yields check, which holds every algorithm's yields and every node's answer shape within the math type's shapes, the ontology resolution gate over every record that names the math type",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every algorithm record, node, axis and substrate node that names the math type",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the math type's shapes or a record that names it changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a yield or answer shape outside the type's shapes, or a reference to a type that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a math type is a family of answers, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a node with a dangling math type, another plants an answer shape outside the type's shapes, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The math type's shapes, which every yield and answer shape conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-math-type-algebra",
            "title": "algebra"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "How do states vary?",
                    "term": "Question"
                  },
                  {
                    "description": "[analysis](/records/reasoning/math-domain-analysis)",
                    "term": "Fields"
                  },
                  {
                    "description": "operation applied to state",
                    "term": "Predicate family"
                  },
                  {
                    "description": "operation",
                    "term": "Yields shape"
                  },
                  {
                    "description": "[Non-Destructive Domain Investigation](/records/algorithms/non-destructive-domain-investigation), [Risk Complexity Reversibility](/records/algorithms/risk-complexity-reversibility), [Event Messaging](/records/algorithms/event-messaging), [Streaming Dataflow](/records/algorithms/streaming-dataflow), [Measurement Normalization](/records/algorithms/measurement-normalization), [Breaking Point Calculation](/records/algorithms/breaking-point-calculation), [Scalability Projection](/records/algorithms/scalability-projection), [Behavioral Signature Extraction](/records/algorithms/behavioral-signature-extraction)",
                    "term": "Contracts"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the yields check, which holds every algorithm's yields and every node's answer shape within the math type's shapes, the ontology resolution gate over every record that names the math type",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every algorithm record, node, axis and substrate node that names the math type",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the math type's shapes or a record that names it changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a yield or answer shape outside the type's shapes, or a reference to a type that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a math type is a family of answers, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a node with a dangling math type, another plants an answer shape outside the type's shapes, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The math type's shapes, which every yield and answer shape conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-math-type-analysis",
            "title": "analysis"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "What is admissible or best?",
                    "term": "Question"
                  },
                  {
                    "description": "validation · threshold · argmax",
                    "term": "Predicate family"
                  },
                  {
                    "description": "boolean | ranking | number",
                    "term": "Yields shape"
                  },
                  {
                    "description": "[Creation History Collision](/records/algorithms/creation-history-collision), [Adaptive Phase Boundary](/records/algorithms/adaptive-phase-boundary), [Replacement Safety](/records/algorithms/replacement-safety), [First-Time Initiation](/records/algorithms/first-time-initiation), [Architectural Style Boundary](/records/algorithms/architectural-style-boundary), [Verification Fitness](/records/algorithms/verification-fitness), [Performance Scaling](/records/algorithms/performance-scaling), [Architecture Selection Meta-Algorithm](/records/algorithms/architecture-selection-meta-algorithm), [Severity Policy](/records/algorithms/severity-policy), [Refactor Selection](/records/algorithms/refactor-selection), [Architecture Assessment](/records/algorithms/architecture-assessment), [Pattern Selection](/records/algorithms/pattern-selection), [Performance and Scalability](/records/algorithms/performance-and-scalability), [Architecture Evolution Governance](/records/algorithms/architecture-evolution-governance), [Architectural Recommendation](/records/algorithms/architectural-recommendation), [Architecture Decision Support](/records/algorithms/architecture-decision-support), [Static-to-Dynamic Readiness](/records/algorithms/static-to-dynamic-readiness), [Automation Operation Mode](/records/algorithms/automation-operation-mode), [Automation Priority Ordering](/records/algorithms/automation-priority-ordering), [Operation Mode Gating](/records/algorithms/operation-mode-gating), [Canonical Variation Selection](/records/algorithms/canonical-variation-selection), [Developer Decision Gate](/records/algorithms/developer-decision-gate), [Teleological Intent Gate](/records/algorithms/teleological-intent-gate), [Severity Assignment](/records/algorithms/severity-assignment), [Admissibility Constraint Gate](/records/algorithms/admissibility-constraint-stage), [Severity Failure Routing](/records/algorithms/severity-failure-routing), [Severity-Ordered Remediation](/records/algorithms/severity-ordered-remediation), [Phase-Separated Execution](/records/algorithms/phase-separated-execution), [Validation Gate](/records/algorithms/validation-gate), [Coverage Risk Prioritization](/records/algorithms/coverage-risk-prioritization), [PAG Invariant Record](/records/algorithms/pag-constraint-boundary), [Anti-Pattern Priority Matrix](/records/algorithms/anti-pattern-priority-matrix), [Boundary Reconciliation](/records/algorithms/boundary-reconciliation), [Phase Close Gate](/records/algorithms/phase-close-gate), [Bounded Cascade Termination](/records/algorithms/bounded-cascade-termination), [Layer Fitness Enforcement](/records/algorithms/layer-fitness-enforcement), [Reshape Risk Priority](/records/algorithms/reshape-risk-priority), [Vocabulary Admission Gate](/records/algorithms/vocabulary-admission-gate)",
                    "term": "Contracts"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the yields check, which holds every algorithm's yields and every node's answer shape within the math type's shapes, the ontology resolution gate over every record that names the math type",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every algorithm record, node, axis and substrate node that names the math type",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the math type's shapes or a record that names it changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a yield or answer shape outside the type's shapes, or a reference to a type that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a math type is a family of answers, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a node with a dangling math type, another plants an answer shape outside the type's shapes, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The math type's shapes, which every yield and answer shape conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-math-type-optimization",
            "title": "optimization"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "What is preserved under change?",
                    "term": "Question"
                  },
                  {
                    "description": "[topology](/records/reasoning/math-domain-topology)",
                    "term": "Fields"
                  },
                  {
                    "description": "invariant / symmetry",
                    "term": "Predicate family"
                  },
                  {
                    "description": "boolean",
                    "term": "Yields shape"
                  },
                  {
                    "description": "[Domain Boundary](/records/algorithms/domain-boundary), [Portability Environment](/records/algorithms/portability-environment), [Fractal Scale Duplication](/records/algorithms/fractal-scale-duplication), [Placement Isolation](/records/algorithms/placement-isolation)",
                    "term": "Contracts"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the yields check, which holds every algorithm's yields and every node's answer shape within the math type's shapes, the ontology resolution gate over every record that names the math type",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every algorithm record, node, axis and substrate node that names the math type",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the math type's shapes or a record that names it changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a yield or answer shape outside the type's shapes, or a reference to a type that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a math type is a family of answers, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a node with a dangling math type, another plants an answer shape outside the type's shapes, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The math type's shapes, which every yield and answer shape conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-math-type-topology",
            "title": "topology"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "How certain or likely is it?",
                    "term": "Question"
                  },
                  {
                    "description": "[probability](/records/reasoning/math-domain-probability)",
                    "term": "Fields"
                  },
                  {
                    "description": "confidence · distribution · counter",
                    "term": "Predicate family"
                  },
                  {
                    "description": "number[0,1]",
                    "term": "Yields shape"
                  },
                  {
                    "description": "[Knowledge Documentation Relevance](/records/algorithms/knowledge-documentation-relevance), [Evidence Grounding Validation](/records/algorithms/evidence-grounding-validation), [RAG Knowledge Boundary](/records/algorithms/rag-knowledge-boundary), [Queuing Theory](/records/algorithms/queuing-theory), [Convention Strength Analysis](/records/algorithms/convention-strength-analysis), [Research Guidance](/records/algorithms/research-guidance), [Validation Score](/records/algorithms/validation-score), [Tool Calibration](/records/algorithms/tool-calibration), [Recursive Self-Verification](/records/algorithms/recursive-self-verification), [Compliance Gap](/records/algorithms/compliance-gap), [Behavioral Inconsistency](/records/algorithms/behavioral-inconsistency), [Anomaly Outlier Detection](/records/algorithms/anomaly-outlier-detection), [Distillation Metrics](/records/algorithms/distillation-metrics)",
                    "term": "Contracts"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the yields check, which holds every algorithm's yields and every node's answer shape within the math type's shapes, the ontology resolution gate over every record that names the math type",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every algorithm record, node, axis and substrate node that names the math type",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the math type's shapes or a record that names it changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a yield or answer shape outside the type's shapes, or a reference to a type that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a math type is a family of answers, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a node with a dangling math type, another plants an answer shape outside the type's shapes, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The math type's shapes, which every yield and answer shape conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-math-type-probability",
            "title": "probability"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "What is novel, and how compressible is it?",
                    "term": "Question"
                  },
                  {
                    "description": "[information-theory](/records/reasoning/math-domain-information-theory)",
                    "term": "Fields"
                  },
                  {
                    "description": "novelty · dedup · hash",
                    "term": "Predicate family"
                  },
                  {
                    "description": "hash | novelty-score | boolean",
                    "term": "Yields shape"
                  },
                  {
                    "description": "[Audit Artifact](/records/algorithms/audit-artifact), [Final Generation Report](/records/algorithms/final-generation-report), [Template Assembly](/records/algorithms/template-assembly), [Automation Session Report](/records/algorithms/automation-session-report), [Centralization Report](/records/algorithms/centralization-report), [Rendering Stage](/records/algorithms/rendering-stage), [Checklist Output Rendering](/records/algorithms/checklist-output-rendering), [Partial Success Reporting](/records/algorithms/partial-success-reporting), [Completion Report](/records/algorithms/completion-report), [Investigation Report](/records/algorithms/investigation-report), [Action Log](/records/algorithms/action-log), [Coverage Ledger](/records/algorithms/coverage-ledger), [Conceptual Duplication Detection](/records/algorithms/conceptual-duplication-detection), [Pattern Distillation History](/records/algorithms/pattern-distillation-history), [Version Provenance](/records/algorithms/version-provenance), [Living Plan State](/records/algorithms/living-plan-state), [Versioned Turn Provenance](/records/algorithms/versioned-turn-provenance), [Taxonomy Ledger](/records/algorithms/taxonomy-ledger)",
                    "term": "Contracts"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the yields check, which holds every algorithm's yields and every node's answer shape within the math type's shapes, the ontology resolution gate over every record that names the math type",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every algorithm record, node, axis and substrate node that names the math type",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the math type's shapes or a record that names it changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a yield or answer shape outside the type's shapes, or a reference to a type that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a math type is a family of answers, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a node with a dangling math type, another plants an answer shape outside the type's shapes, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The math type's shapes, which every yield and answer shape conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-math-type-information-theory",
            "title": "information-theory"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "What procedure produces it?",
                    "term": "Question"
                  },
                  {
                    "description": "[computation](/records/reasoning/math-domain-computation)",
                    "term": "Fields"
                  },
                  {
                    "description": "algorithm / loop",
                    "term": "Predicate family"
                  },
                  {
                    "description": "procedure",
                    "term": "Yields shape"
                  },
                  {
                    "description": "[Portable Contract Composition](/records/algorithms/portable-contract-composition), [Adapter Rendering](/records/algorithms/adapter-rendering), [Agent Creator Kernel](/records/algorithms/agent-creator-kernel), [Agent Workflow File Modification Recovery](/records/algorithms/agent-workflow-file-modification-recovery), [Shared Document Workspace](/records/algorithms/shared-document-workspace), [Agent Document Responsibility](/records/algorithms/agent-document-responsibility), [Agent Activation Invocation](/records/algorithms/agent-activation-invocation), [Parallel Batch Execution](/records/algorithms/parallel-batch-execution), [Sequential Agent Execution](/records/algorithms/sequential-agent-execution), [Workflow Coordination Sequence](/records/algorithms/workflow-coordination-sequence), [Checklist Integration](/records/algorithms/checklist-integration), [Phase Documentation Template](/records/algorithms/phase-documentation-template), [Capability Invocation Protocol](/records/algorithms/capability-invocation-protocol), [Workflow Creation Kernel](/records/algorithms/workflow-creation-kernel), [Anti-Pattern Rule Compiler](/records/algorithms/anti-pattern-rule-compiler), [Architectural Contract Kernel](/records/algorithms/architectural-contract-kernel), [Construction Boundary](/records/algorithms/construction-boundary), [Saga Compensation](/records/algorithms/saga-compensation), [Declarative Metaprogramming](/records/algorithms/declarative-metaprogramming), [Manifest-Driven Documentation](/records/algorithms/manifest-driven-documentation), [Architecture Fitness Function Generation](/records/algorithms/architecture-fitness-function-generation), [Architecture Catalog Compiler](/records/algorithms/architecture-catalog-compiler), [Master Architecture Governance Kernel](/records/algorithms/master-architecture-governance-kernel), [Centralized Reference Resolver](/records/algorithms/centralized-reference-resolver), [Manual Fallback Preservation](/records/algorithms/manual-fallback-preservation), [Entry Point Migration](/records/algorithms/entry-point-migration), [Knowledge Capture](/records/algorithms/knowledge-capture), [Automation Kernel](/records/algorithms/automation-kernel), [Replacement Refactor](/records/algorithms/replacement-refactor), [Rollback-Centered Execution](/records/algorithms/rollback-centered-execution), [Centralization Kernel](/records/algorithms/centralization-kernel), [Dynamic Discovery Pattern Generation](/records/algorithms/dynamic-discovery-pattern-generation), [Compilation Stage](/records/algorithms/compilation-stage), [Verb Template Binding](/records/algorithms/verb-template-binding), [Task Atomization](/records/algorithms/task-atomization), [Checklist Creation Kernel](/records/algorithms/checklist-creation-kernel), [File-Scoped Fix](/records/algorithms/file-scoped-fix), [File Limit Remediation](/records/algorithms/file-limit-remediation), [Import Boundary Remediation](/records/algorithms/import-boundary-remediation), [Naming Convention Remediation](/records/algorithms/naming-convention-remediation), [Base-Class Compliance Remediation](/records/algorithms/base-class-compliance-remediation), [CSS Token Remediation](/records/algorithms/css-token-remediation), [DOM Factory Remediation](/records/algorithms/dom-factory-remediation), [Console Usage Remediation](/records/algorithms/console-usage-remediation), [Lifecycle Symmetry Remediation](/records/algorithms/lifecycle-symmetry-remediation), [Stylelint Post-Fix](/records/algorithms/stylelint-post-fix), [Codebase Verification Kernel](/records/algorithms/codebase-verification-kernel), [File Modification Recovery](/records/algorithms/file-modification-recovery), [Defensive String Normalization](/records/algorithms/defensive-string-normalization), [Advanced Tool Escalation](/records/algorithms/advanced-tool-escalation), [Contract-Based Verification Kernel](/records/algorithms/contract-based-verification-kernel), [Convergence Walk](/records/algorithms/convergence-walk), [Test Authoring](/records/algorithms/test-authoring), [Test Coverage Kernel](/records/algorithms/test-coverage-kernel), [PAG Semantic Operation](/records/algorithms/pag-tool-invocation), [PAG Authoring Kernel](/records/algorithms/pag-authoring-kernel), [Base Schematic Composition](/records/algorithms/base-schematic-composition), [Backup-Verified Migration](/records/algorithms/backup-verified-migration), [Registry Regeneration](/records/algorithms/registry-regeneration), [Anti-Reintroduction Gate](/records/algorithms/anti-reintroduction-gate), [Pattern Distiller Kernel](/records/algorithms/pattern-distiller-kernel), [Idempotent Merge](/records/algorithms/idempotent-merge), [Deterministic Merge Core](/records/algorithms/deterministic-merge-core), [Persistence Fork](/records/algorithms/persistence-fork), [Living Profile Kernel](/records/algorithms/living-profile-kernel), [Governed Autonomous Plan Loop](/records/algorithms/governed-autonomous-plan-loop), [Quality Governance Loop](/records/algorithms/quality-governance-loop), [Comment Normalization Remediation](/records/algorithms/comment-normalization-remediation), [Custom-Rule Derivation](/records/algorithms/custom-rule-derivation), [Composed Turn Contract](/records/algorithms/composed-turn-contract), [Loop-Owned Mode Selection](/records/algorithms/loop-owned-mode-selection), [Governed Construction Boundary](/records/algorithms/governed-construction-boundary), [Type-Migration Centralization](/records/algorithms/type-migration-centralization), [Container Reshape](/records/algorithms/container-reshape), [Taxonomy Kernel](/records/algorithms/taxonomy-kernel)",
                    "term": "Contracts"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the yields check, which holds every algorithm's yields and every node's answer shape within the math type's shapes, the ontology resolution gate over every record that names the math type",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every algorithm record, node, axis and substrate node that names the math type",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the math type's shapes or a record that names it changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a yield or answer shape outside the type's shapes, or a reference to a type that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a math type is a family of answers, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a node with a dangling math type, another plants an answer shape outside the type's shapes, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The math type's shapes, which every yield and answer shape conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-math-type-computation",
            "title": "computation"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "What stable pattern arises, and has it converged?",
                    "term": "Question"
                  },
                  {
                    "description": "fixed-point · convergence · oscillation",
                    "term": "Predicate family"
                  },
                  {
                    "description": "boolean | counter",
                    "term": "Yields shape"
                  },
                  {
                    "description": "[Workflow Recovery Loop](/records/algorithms/workflow-recovery-loop), [Anti-Pattern Propagation Kernel](/records/algorithms/anti-pattern-propagation-kernel), [Resilience Control](/records/algorithms/resilience-control), [Recovery Deployment](/records/algorithms/recovery-deployment), [Iterative Variation Discovery](/records/algorithms/iterative-variation-discovery), [Repair Stage](/records/algorithms/repair-stage), [Bounded Repair Loop](/records/algorithms/bounded-repair-loop), [Verification Loop](/records/algorithms/verification-loop), [Iteration Bound](/records/algorithms/iteration-bound), [Recursion Control](/records/algorithms/recursion-control)",
                    "term": "Contracts"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the yields check, which holds every algorithm's yields and every node's answer shape within the math type's shapes, the ontology resolution gate over every record that names the math type",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every algorithm record, node, axis and substrate node that names the math type",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the math type's shapes or a record that names it changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a yield or answer shape outside the type's shapes, or a reference to a type that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a math type is a family of answers, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a node with a dangling math type, another plants an answer shape outside the type's shapes, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The math type's shapes, which every yield and answer shape conforms to",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-math-type-dynamical-systems",
            "title": "dynamical-systems"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "quantity",
                    "term": "Studies"
                  },
                  {
                    "description": "What can be counted or measured?",
                    "term": "Question"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over the math types and foundations that name the domain",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every math type and foundation layer that names the domain",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the domain list or a record that names a domain changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a reference to a domain that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a math domain is a field of study, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a math type that names a missing domain, and the bundled references resolve",
                    "term": "Evidence"
                  },
                  {
                    "description": "The domain list, which every math type and foundation that names a domain cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-math-domain-number",
            "title": "number"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "operations and structures",
                    "term": "Studies"
                  },
                  {
                    "description": "What rules govern transformations?",
                    "term": "Question"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over the math types and foundations that name the domain",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every math type and foundation layer that names the domain",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the domain list or a record that names a domain changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a reference to a domain that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a math domain is a field of study, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a math type that names a missing domain, and the bundled references resolve",
                    "term": "Evidence"
                  },
                  {
                    "description": "The domain list, which every math type and foundation that names a domain cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-math-domain-algebra",
            "title": "algebra"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "space and form",
                    "term": "Studies"
                  },
                  {
                    "description": "What shapes and spaces exist?",
                    "term": "Question"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over the math types and foundations that name the domain",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every math type and foundation layer that names the domain",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the domain list or a record that names a domain changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a reference to a domain that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a math domain is a field of study, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a math type that names a missing domain, and the bundled references resolve",
                    "term": "Evidence"
                  },
                  {
                    "description": "The domain list, which every math type and foundation that names a domain cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-math-domain-geometry",
            "title": "geometry"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "continuity and connectivity",
                    "term": "Studies"
                  },
                  {
                    "description": "What remains invariant under deformation?",
                    "term": "Question"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over the math types and foundations that name the domain",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every math type and foundation layer that names the domain",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the domain list or a record that names a domain changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a reference to a domain that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a math domain is a field of study, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a math type that names a missing domain, and the bundled references resolve",
                    "term": "Evidence"
                  },
                  {
                    "description": "The domain list, which every math type and foundation that names a domain cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-math-domain-topology",
            "title": "topology"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "change and limits",
                    "term": "Studies"
                  },
                  {
                    "description": "How do quantities vary?",
                    "term": "Question"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over the math types and foundations that name the domain",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every math type and foundation layer that names the domain",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the domain list or a record that names a domain changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a reference to a domain that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a math domain is a field of study, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a math type that names a missing domain, and the bundled references resolve",
                    "term": "Evidence"
                  },
                  {
                    "description": "The domain list, which every math type and foundation that names a domain cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-math-domain-analysis",
            "title": "analysis"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "truth and inference",
                    "term": "Studies"
                  },
                  {
                    "description": "What statements follow from others?",
                    "term": "Question"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over the math types and foundations that name the domain",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every math type and foundation layer that names the domain",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the domain list or a record that names a domain changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a reference to a domain that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a math domain is a field of study, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a math type that names a missing domain, and the bundled references resolve",
                    "term": "Evidence"
                  },
                  {
                    "description": "The domain list, which every math type and foundation that names a domain cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-math-domain-logic",
            "title": "logic"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "collection and membership",
                    "term": "Studies"
                  },
                  {
                    "description": "What objects can be constructed?",
                    "term": "Question"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over the math types and foundations that name the domain",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every math type and foundation layer that names the domain",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the domain list or a record that names a domain changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a reference to a domain that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a math domain is a field of study, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a math type that names a missing domain, and the bundled references resolve",
                    "term": "Evidence"
                  },
                  {
                    "description": "The domain list, which every math type and foundation that names a domain cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-math-domain-set-theory",
            "title": "set-theory"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "discrete arrangements",
                    "term": "Studies"
                  },
                  {
                    "description": "How many configurations exist?",
                    "term": "Question"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over the math types and foundations that name the domain",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every math type and foundation layer that names the domain",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the domain list or a record that names a domain changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a reference to a domain that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a math domain is a field of study, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a math type that names a missing domain, and the bundled references resolve",
                    "term": "Evidence"
                  },
                  {
                    "description": "The domain list, which every math type and foundation that names a domain cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-math-domain-combinatorics",
            "title": "combinatorics"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "uncertainty",
                    "term": "Studies"
                  },
                  {
                    "description": "What outcomes are possible and likely?",
                    "term": "Question"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over the math types and foundations that name the domain",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every math type and foundation layer that names the domain",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the domain list or a record that names a domain changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a reference to a domain that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a math domain is a field of study, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a math type that names a missing domain, and the bundled references resolve",
                    "term": "Evidence"
                  },
                  {
                    "description": "The domain list, which every math type and foundation that names a domain cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-math-domain-probability",
            "title": "probability"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "information and compression",
                    "term": "Studies"
                  },
                  {
                    "description": "What patterns can be encoded?",
                    "term": "Question"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over the math types and foundations that name the domain",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every math type and foundation layer that names the domain",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the domain list or a record that names a domain changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a reference to a domain that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a math domain is a field of study, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a math type that names a missing domain, and the bundled references resolve",
                    "term": "Evidence"
                  },
                  {
                    "description": "The domain list, which every math type and foundation that names a domain cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-math-domain-information-theory",
            "title": "information-theory"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "procedures and algorithms",
                    "term": "Studies"
                  },
                  {
                    "description": "What can be generated or solved?",
                    "term": "Question"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over the math types and foundations that name the domain",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every math type and foundation layer that names the domain",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the domain list or a record that names a domain changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a reference to a domain that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a math domain is a field of study, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a math type that names a missing domain, and the bundled references resolve",
                    "term": "Evidence"
                  },
                  {
                    "description": "The domain list, which every math type and foundation that names a domain cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-math-domain-computation",
            "title": "computation"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "relationships between structures",
                    "term": "Studies"
                  },
                  {
                    "description": "How do mathematical worlds connect?",
                    "term": "Question"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over the math types and foundations that name the domain",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every math type and foundation layer that names the domain",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the domain list or a record that names a domain changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a reference to a domain that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a math domain is a field of study, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a math type that names a missing domain, and the bundled references resolve",
                    "term": "Evidence"
                  },
                  {
                    "description": "The domain list, which every math type and foundation that names a domain cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-math-domain-category-theory",
            "title": "category-theory"
          }
        ],
        "title": "The mathematics"
      },
      {
        "icon": "bi-signpost-split",
        "id": "the-dimensions",
        "intro": "The ontological dimensions are what can be observed about a subject, and each is listed with the test surfaces that observe it.",
        "subsections": [
          {
            "blocks": [
              {
                "items": [
                  "Nature: object"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "What exists?",
                    "term": "Question"
                  },
                  {
                    "description": "[data-correctness](/records/reasoning/test-surface-data-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test-surface catalog, which pairs each dimension with a lens and the techniques that check the pair, the ontology resolution gate over every surface and node that names the dimension",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every test surface and ontology node that names the dimension",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the dimension, the surfaces that name it or their lenses change",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a surface or node that names a dimension that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a dimension is a question asked of a system; the techniques its surfaces list observe the system",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a surface whose dimension does not exist, and the bundled surfaces validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The dimension list, which every surface and node that names a dimension cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-dimension-identity",
            "title": "identity"
          },
          {
            "blocks": [
              {
                "items": [
                  "Nature: elements"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "What is it made of?",
                    "term": "Question"
                  },
                  {
                    "description": "[memory-correctness](/records/reasoning/test-surface-memory-correctness), [resource-correctness](/records/reasoning/test-surface-resource-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test-surface catalog, which pairs each dimension with a lens and the techniques that check the pair, the ontology resolution gate over every surface and node that names the dimension",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every test surface and ontology node that names the dimension",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the dimension, the surfaces that name it or their lenses change",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a surface or node that names a dimension that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a dimension is a question asked of a system; the techniques its surfaces list observe the system",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a surface whose dimension does not exist, and the bundled surfaces validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The dimension list, which every surface and node that names a dimension cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-dimension-composition",
            "title": "composition"
          },
          {
            "blocks": [
              {
                "items": [
                  "Nature: arrangement"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "How are parts arranged?",
                    "term": "Question"
                  },
                  {
                    "description": "[interface-correctness](/records/reasoning/test-surface-interface-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test-surface catalog, which pairs each dimension with a lens and the techniques that check the pair, the ontology resolution gate over every surface and node that names the dimension",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every test surface and ontology node that names the dimension",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the dimension, the surfaces that name it or their lenses change",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a surface or node that names a dimension that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a dimension is a question asked of a system; the techniques its surfaces list observe the system",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a surface whose dimension does not exist, and the bundled surfaces validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The dimension list, which every surface and node that names a dimension cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-dimension-structure",
            "title": "structure"
          },
          {
            "blocks": [
              {
                "items": [
                  "Nature: mapping"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "What connects it to other things?",
                    "term": "Question"
                  },
                  {
                    "description": "[interaction-correctness](/records/reasoning/test-surface-interaction-correctness), [consistency-correctness](/records/reasoning/test-surface-consistency-correctness), [protocol-correctness](/records/reasoning/test-surface-protocol-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test-surface catalog, which pairs each dimension with a lens and the techniques that check the pair, the ontology resolution gate over every surface and node that names the dimension",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every test surface and ontology node that names the dimension",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the dimension, the surfaces that name it or their lenses change",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a surface or node that names a dimension that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a dimension is a question asked of a system; the techniques its surfaces list observe the system",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a surface whose dimension does not exist, and the bundled surfaces validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The dimension list, which every surface and node that names a dimension cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-dimension-relation",
            "title": "relation"
          },
          {
            "blocks": [
              {
                "items": [
                  "Nature: position"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Where is it?",
                    "term": "Question"
                  },
                  {
                    "description": "[geometry](/records/reasoning/math-domain-geometry)",
                    "term": "Fields"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test-surface catalog, which pairs each dimension with a lens and the techniques that check the pair, the ontology resolution gate over every surface and node that names the dimension",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every test surface and ontology node that names the dimension",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the dimension, the surfaces that name it or their lenses change",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a surface or node that names a dimension that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a dimension is a question asked of a system; the techniques its surfaces list observe the system",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a surface whose dimension does not exist, and the bundled surfaces validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The dimension list, which every surface and node that names a dimension cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-dimension-space",
            "title": "space"
          },
          {
            "blocks": [
              {
                "items": [
                  "Nature: process"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "When does it occur?",
                    "term": "Question"
                  },
                  {
                    "description": "[temporal-correctness](/records/reasoning/test-surface-temporal-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test-surface catalog, which pairs each dimension with a lens and the techniques that check the pair, the ontology resolution gate over every surface and node that names the dimension",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every test surface and ontology node that names the dimension",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the dimension, the surfaces that name it or their lenses change",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a surface or node that names a dimension that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a dimension is a question asked of a system; the techniques its surfaces list observe the system",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a surface whose dimension does not exist, and the bundled surfaces validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The dimension list, which every surface and node that names a dimension cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-dimension-time",
            "title": "time"
          },
          {
            "blocks": [
              {
                "items": [
                  "Nature: condition"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "What condition is it in?",
                    "term": "Question"
                  },
                  {
                    "description": "[state-correctness](/records/reasoning/test-surface-state-correctness), [configuration-correctness](/records/reasoning/test-surface-configuration-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test-surface catalog, which pairs each dimension with a lens and the techniques that check the pair, the ontology resolution gate over every surface and node that names the dimension",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every test surface and ontology node that names the dimension",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the dimension, the surfaces that name it or their lenses change",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a surface or node that names a dimension that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a dimension is a question asked of a system; the techniques its surfaces list observe the system",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a surface whose dimension does not exist, and the bundled surfaces validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The dimension list, which every surface and node that names a dimension cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-dimension-state",
            "title": "state"
          },
          {
            "blocks": [
              {
                "items": [
                  "Nature: operation"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "How does it transform?",
                    "term": "Question"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test-surface catalog, which pairs each dimension with a lens and the techniques that check the pair, the ontology resolution gate over every surface and node that names the dimension",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every test surface and ontology node that names the dimension",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the dimension, the surfaces that name it or their lenses change",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a surface or node that names a dimension that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a dimension is a question asked of a system; the techniques its surfaces list observe the system",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a surface whose dimension does not exist, and the bundled surfaces validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The dimension list, which every surface and node that names a dimension cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-dimension-change",
            "title": "change"
          },
          {
            "blocks": [
              {
                "items": [
                  "Nature: dynamics"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "What does it do?",
                    "term": "Question"
                  },
                  {
                    "description": "[concurrency-correctness](/records/reasoning/test-surface-concurrency-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test-surface catalog, which pairs each dimension with a lens and the techniques that check the pair, the ontology resolution gate over every surface and node that names the dimension",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every test surface and ontology node that names the dimension",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the dimension, the surfaces that name it or their lenses change",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a surface or node that names a dimension that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a dimension is a question asked of a system; the techniques its surfaces list observe the system",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a surface whose dimension does not exist, and the bundled surfaces validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The dimension list, which every surface and node that names a dimension cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-dimension-behavior",
            "title": "behavior"
          },
          {
            "blocks": [
              {
                "items": [
                  "Nature: mapping"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "What role does it fulfill?",
                    "term": "Question"
                  },
                  {
                    "description": "[functional-correctness](/records/reasoning/test-surface-functional-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test-surface catalog, which pairs each dimension with a lens and the techniques that check the pair, the ontology resolution gate over every surface and node that names the dimension",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every test surface and ontology node that names the dimension",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the dimension, the surfaces that name it or their lenses change",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a surface or node that names a dimension that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a dimension is a question asked of a system; the techniques its surfaces list observe the system",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a surface whose dimension does not exist, and the bundled surfaces validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The dimension list, which every surface and node that names a dimension cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-dimension-function",
            "title": "function"
          },
          {
            "blocks": [
              {
                "items": [
                  "Nature: mechanism"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Why does it happen?",
                    "term": "Question"
                  },
                  {
                    "description": "[security-correctness](/records/reasoning/test-surface-security-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test-surface catalog, which pairs each dimension with a lens and the techniques that check the pair, the ontology resolution gate over every surface and node that names the dimension",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every test surface and ontology node that names the dimension",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the dimension, the surfaces that name it or their lenses change",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a surface or node that names a dimension that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a dimension is a question asked of a system; the techniques its surfaces list observe the system",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a surface whose dimension does not exist, and the bundled surfaces validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The dimension list, which every surface and node that names a dimension cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-dimension-cause",
            "title": "cause"
          },
          {
            "blocks": [
              {
                "items": [
                  "Nature: semantics"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "What does it signify?",
                    "term": "Question"
                  },
                  {
                    "description": "[semantic-correctness](/records/reasoning/test-surface-semantic-correctness), [observability-correctness](/records/reasoning/test-surface-observability-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test-surface catalog, which pairs each dimension with a lens and the techniques that check the pair, the ontology resolution gate over every surface and node that names the dimension",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every test surface and ontology node that names the dimension",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the dimension, the surfaces that name it or their lenses change",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a surface or node that names a dimension that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a dimension is a question asked of a system; the techniques its surfaces list observe the system",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a surface whose dimension does not exist, and the bundled surfaces validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The dimension list, which every surface and node that names a dimension cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-dimension-meaning",
            "title": "meaning"
          },
          {
            "blocks": [
              {
                "items": [
                  "Nature: hierarchy"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "At what level does it exist?",
                    "term": "Question"
                  },
                  {
                    "description": "[performance-correctness](/records/reasoning/test-surface-performance-correctness), [numerical-correctness](/records/reasoning/test-surface-numerical-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test-surface catalog, which pairs each dimension with a lens and the techniques that check the pair, the ontology resolution gate over every surface and node that names the dimension",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every test surface and ontology node that names the dimension",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the dimension, the surfaces that name it or their lenses change",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a surface or node that names a dimension that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a dimension is a question asked of a system; the techniques its surfaces list observe the system",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a surface whose dimension does not exist, and the bundled surfaces validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The dimension list, which every surface and node that names a dimension cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-dimension-scale",
            "title": "scale"
          },
          {
            "blocks": [
              {
                "items": [
                  "Nature: distribution"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "How certain is it?",
                    "term": "Question"
                  },
                  {
                    "description": "[reliability-correctness](/records/reasoning/test-surface-reliability-correctness), [availability-correctness](/records/reasoning/test-surface-availability-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test-surface catalog, which pairs each dimension with a lens and the techniques that check the pair, the ontology resolution gate over every surface and node that names the dimension",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every test surface and ontology node that names the dimension",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the dimension, the surfaces that name it or their lenses change",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a surface or node that names a dimension that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a dimension is a question asked of a system; the techniques its surfaces list observe the system",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a surface whose dimension does not exist, and the bundled surfaces validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The dimension list, which every surface and node that names a dimension cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-dimension-probability",
            "title": "probability"
          },
          {
            "blocks": [
              {
                "items": [
                  "Nature: creation"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "What deviates from expectation?",
                    "term": "Question"
                  },
                  {
                    "description": "[determinism-correctness](/records/reasoning/test-surface-determinism-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test-surface catalog, which pairs each dimension with a lens and the techniques that check the pair, the ontology resolution gate over every surface and node that names the dimension",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every test surface and ontology node that names the dimension",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the dimension, the surfaces that name it or their lenses change",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a surface or node that names a dimension that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a dimension is a question asked of a system; the techniques its surfaces list observe the system",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a surface whose dimension does not exist, and the bundled surfaces validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The dimension list, which every surface and node that names a dimension cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-dimension-novelty",
            "title": "novelty"
          }
        ],
        "title": "The dimensions"
      },
      {
        "icon": "bi-signpost-split",
        "id": "the-lenses",
        "intro": "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.",
        "subsections": [
          {
            "blocks": [
              {
                "items": [
                  "Nature: arrangement",
                  "Universal axis: [arrangement](/records/reasoning/universal-axis-arrangement)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "How are the parts organized?",
                    "term": "Question"
                  },
                  {
                    "description": "[algebra](/records/reasoning/math-domain-algebra), [category-theory](/records/reasoning/math-domain-category-theory)",
                    "term": "Fields"
                  },
                  {
                    "description": "structural_duplication, copy_paste_duplication",
                    "term": "Surfaces"
                  },
                  {
                    "description": "[Behavioral Signature Extraction](/records/algorithms/behavioral-signature-extraction), [Cross-Class Pattern Detection](/records/algorithms/cross-class-pattern-detection)",
                    "term": "Detectors"
                  },
                  {
                    "description": "[interface-correctness](/records/reasoning/test-surface-interface-correctness), [data-correctness](/records/reasoning/test-surface-data-correctness), [configuration-correctness](/records/reasoning/test-surface-configuration-correctness)",
                    "term": "Test surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the detectors each lens names, which resolve to algorithms records and scan code for the lens's duplication shapes, the test-surface catalog, which pairs each lens with a dimension",
                    "term": "Checked by"
                  },
                  {
                    "description": "The code the lens's detectors scan, and every surface that names the lens",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the scanned code, a detector or a surface changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a detector that resolves to no record, or a surface that names an unknown lens",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a lens is a way of reading structure; its detectors read source, not a running system",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface whose lens does not exist, another plants a detector that resolves to no record, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The lens list and the algorithm records, which a surface and a detector cite",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-lens-structure",
            "title": "structure"
          },
          {
            "blocks": [
              {
                "items": [
                  "Nature: time",
                  "Universal axis: [dynamics](/records/reasoning/universal-axis-dynamics)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "How does it vary through time?",
                    "term": "Question"
                  },
                  {
                    "description": "differential-equations, dynamical-systems",
                    "term": "Fields"
                  },
                  {
                    "description": "temporal_coupling",
                    "term": "Surfaces"
                  },
                  {
                    "description": "[Temporal Coupling Detection](/records/algorithms/temporal-coupling-detection)",
                    "term": "Detectors"
                  },
                  {
                    "description": "[temporal-correctness](/records/reasoning/test-surface-temporal-correctness), [concurrency-correctness](/records/reasoning/test-surface-concurrency-correctness), [availability-correctness](/records/reasoning/test-surface-availability-correctness)",
                    "term": "Test surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the detectors each lens names, which resolve to algorithms records and scan code for the lens's duplication shapes, the test-surface catalog, which pairs each lens with a dimension",
                    "term": "Checked by"
                  },
                  {
                    "description": "The code the lens's detectors scan, and every surface that names the lens",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the scanned code, a detector or a surface changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a detector that resolves to no record, or a surface that names an unknown lens",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a lens is a way of reading structure; its detectors read source, not a running system",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface whose lens does not exist, another plants a detector that resolves to no record, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The lens list and the algorithm records, which a surface and a detector cite",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-lens-time",
            "title": "time"
          },
          {
            "blocks": [
              {
                "items": [
                  "Nature: location",
                  "Universal axis: [arrangement](/records/reasoning/universal-axis-arrangement)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "How is it distributed in space?",
                    "term": "Question"
                  },
                  {
                    "description": "[geometry](/records/reasoning/math-domain-geometry), [topology](/records/reasoning/math-domain-topology)",
                    "term": "Fields"
                  },
                  {
                    "description": "none",
                    "term": "Surfaces"
                  },
                  {
                    "description": "none",
                    "term": "Detectors"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the detectors each lens names, which resolve to algorithms records and scan code for the lens's duplication shapes, the test-surface catalog, which pairs each lens with a dimension",
                    "term": "Checked by"
                  },
                  {
                    "description": "The code the lens's detectors scan, and every surface that names the lens",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the scanned code, a detector or a surface changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a detector that resolves to no record, or a surface that names an unknown lens",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a lens is a way of reading structure; its detectors read source, not a running system",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface whose lens does not exist, another plants a detector that resolves to no record, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The lens list and the algorithm records, which a surface and a detector cite",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-lens-space",
            "title": "space"
          },
          {
            "blocks": [
              {
                "items": [
                  "Nature: distribution",
                  "Universal axis: [abstraction](/records/reasoning/universal-axis-abstraction)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "What regularities emerge from many observations?",
                    "term": "Question"
                  },
                  {
                    "description": "[probability](/records/reasoning/math-domain-probability), statistics",
                    "term": "Fields"
                  },
                  {
                    "description": "none",
                    "term": "Surfaces"
                  },
                  {
                    "description": "none",
                    "term": "Detectors"
                  },
                  {
                    "description": "[performance-correctness](/records/reasoning/test-surface-performance-correctness), [consistency-correctness](/records/reasoning/test-surface-consistency-correctness)",
                    "term": "Test surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the detectors each lens names, which resolve to algorithms records and scan code for the lens's duplication shapes, the test-surface catalog, which pairs each lens with a dimension",
                    "term": "Checked by"
                  },
                  {
                    "description": "The code the lens's detectors scan, and every surface that names the lens",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the scanned code, a detector or a surface changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a detector that resolves to no record, or a surface that names an unknown lens",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a lens is a way of reading structure; its detectors read source, not a running system",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface whose lens does not exist, another plants a detector that resolves to no record, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The lens list and the algorithm records, which a surface and a detector cite",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-lens-statistical",
            "title": "statistical"
          },
          {
            "blocks": [
              {
                "items": [
                  "Nature: recurrence",
                  "Universal axis: [dynamics](/records/reasoning/universal-axis-dynamics)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "What repeats, and how often?",
                    "term": "Question"
                  },
                  {
                    "description": "harmonic-analysis",
                    "term": "Fields"
                  },
                  {
                    "description": "copy_paste_duplication",
                    "term": "Surfaces"
                  },
                  {
                    "description": "[Cross-Class Pattern Detection](/records/algorithms/cross-class-pattern-detection)",
                    "term": "Detectors"
                  },
                  {
                    "description": "[observability-correctness](/records/reasoning/test-surface-observability-correctness)",
                    "term": "Test surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the detectors each lens names, which resolve to algorithms records and scan code for the lens's duplication shapes, the test-surface catalog, which pairs each lens with a dimension",
                    "term": "Checked by"
                  },
                  {
                    "description": "The code the lens's detectors scan, and every surface that names the lens",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the scanned code, a detector or a surface changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a detector that resolves to no record, or a surface that names an unknown lens",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a lens is a way of reading structure; its detectors read source, not a running system",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface whose lens does not exist, another plants a detector that resolves to no record, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The lens list and the algorithm records, which a surface and a detector cite",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-lens-frequency",
            "title": "frequency"
          },
          {
            "blocks": [
              {
                "items": [
                  "Nature: order",
                  "Universal axis: [dynamics](/records/reasoning/universal-axis-dynamics)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "In what order do things occur?",
                    "term": "Question"
                  },
                  {
                    "description": "[logic](/records/reasoning/math-domain-logic), [combinatorics](/records/reasoning/math-domain-combinatorics)",
                    "term": "Fields"
                  },
                  {
                    "description": "sequential_duplication",
                    "term": "Surfaces"
                  },
                  {
                    "description": "[Sequential Chain Duplication](/records/algorithms/sequential-chain-duplication)",
                    "term": "Detectors"
                  },
                  {
                    "description": "[state-correctness](/records/reasoning/test-surface-state-correctness), [protocol-correctness](/records/reasoning/test-surface-protocol-correctness)",
                    "term": "Test surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the detectors each lens names, which resolve to algorithms records and scan code for the lens's duplication shapes, the test-surface catalog, which pairs each lens with a dimension",
                    "term": "Checked by"
                  },
                  {
                    "description": "The code the lens's detectors scan, and every surface that names the lens",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the scanned code, a detector or a surface changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a detector that resolves to no record, or a surface that names an unknown lens",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a lens is a way of reading structure; its detectors read source, not a running system",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface whose lens does not exist, another plants a detector that resolves to no record, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The lens list and the algorithm records, which a surface and a detector cite",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-lens-sequential",
            "title": "sequential"
          },
          {
            "blocks": [
              {
                "items": [
                  "Nature: relationships",
                  "Universal axis: [interaction](/records/reasoning/universal-axis-interaction)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "What connects what?",
                    "term": "Question"
                  },
                  {
                    "description": "[algebra](/records/reasoning/math-domain-algebra), [category-theory](/records/reasoning/math-domain-category-theory)",
                    "term": "Fields"
                  },
                  {
                    "description": "relational_duplication",
                    "term": "Surfaces"
                  },
                  {
                    "description": "[Relational Graph Duplication](/records/algorithms/relational-graph-duplication)",
                    "term": "Detectors"
                  },
                  {
                    "description": "[interaction-correctness](/records/reasoning/test-surface-interaction-correctness)",
                    "term": "Test surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the detectors each lens names, which resolve to algorithms records and scan code for the lens's duplication shapes, the test-surface catalog, which pairs each lens with a dimension",
                    "term": "Checked by"
                  },
                  {
                    "description": "The code the lens's detectors scan, and every surface that names the lens",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the scanned code, a detector or a surface changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a detector that resolves to no record, or a surface that names an unknown lens",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a lens is a way of reading structure; its detectors read source, not a running system",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface whose lens does not exist, another plants a detector that resolves to no record, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The lens list and the algorithm records, which a surface and a detector cite",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-lens-relation",
            "title": "relation"
          },
          {
            "blocks": [
              {
                "items": [
                  "Nature: action",
                  "Universal axis: [interaction](/records/reasoning/universal-axis-interaction)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "How does an entity tend to act?",
                    "term": "Question"
                  },
                  {
                    "description": "dynamical-systems",
                    "term": "Fields"
                  },
                  {
                    "description": "behavioral_inconsistency",
                    "term": "Surfaces"
                  },
                  {
                    "description": "[Behavioral Inconsistency](/records/algorithms/behavioral-inconsistency), [Behavioral Signature Extraction](/records/algorithms/behavioral-signature-extraction)",
                    "term": "Detectors"
                  },
                  {
                    "description": "[functional-correctness](/records/reasoning/test-surface-functional-correctness), [resource-correctness](/records/reasoning/test-surface-resource-correctness)",
                    "term": "Test surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the detectors each lens names, which resolve to algorithms records and scan code for the lens's duplication shapes, the test-surface catalog, which pairs each lens with a dimension",
                    "term": "Checked by"
                  },
                  {
                    "description": "The code the lens's detectors scan, and every surface that names the lens",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the scanned code, a detector or a surface changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a detector that resolves to no record, or a surface that names an unknown lens",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a lens is a way of reading structure; its detectors read source, not a running system",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface whose lens does not exist, another plants a detector that resolves to no record, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The lens list and the algorithm records, which a surface and a detector cite",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-lens-behavior",
            "title": "behavior"
          },
          {
            "blocks": [
              {
                "items": [
                  "Nature: purpose",
                  "Universal axis: [abstraction](/records/reasoning/universal-axis-abstraction)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "What role does something perform?",
                    "term": "Question"
                  },
                  {
                    "description": "functional-analysis",
                    "term": "Fields"
                  },
                  {
                    "description": "none",
                    "term": "Surfaces"
                  },
                  {
                    "description": "none",
                    "term": "Detectors"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the detectors each lens names, which resolve to algorithms records and scan code for the lens's duplication shapes, the test-surface catalog, which pairs each lens with a dimension",
                    "term": "Checked by"
                  },
                  {
                    "description": "The code the lens's detectors scan, and every surface that names the lens",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the scanned code, a detector or a surface changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a detector that resolves to no record, or a surface that names an unknown lens",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a lens is a way of reading structure; its detectors read source, not a running system",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface whose lens does not exist, another plants a detector that resolves to no record, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The lens list and the algorithm records, which a surface and a detector cite",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-lens-function",
            "title": "function"
          },
          {
            "blocks": [
              {
                "items": [
                  "Nature: meaning",
                  "Universal axis: [abstraction](/records/reasoning/universal-axis-abstraction)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "What meaning is conveyed?",
                    "term": "Question"
                  },
                  {
                    "description": "none",
                    "term": "Fields"
                  },
                  {
                    "description": "conceptual_duplication",
                    "term": "Surfaces"
                  },
                  {
                    "description": "[Conceptual Duplication Detection](/records/algorithms/conceptual-duplication-detection)",
                    "term": "Detectors"
                  },
                  {
                    "description": "[semantic-correctness](/records/reasoning/test-surface-semantic-correctness)",
                    "term": "Test surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the detectors each lens names, which resolve to algorithms records and scan code for the lens's duplication shapes, the test-surface catalog, which pairs each lens with a dimension",
                    "term": "Checked by"
                  },
                  {
                    "description": "The code the lens's detectors scan, and every surface that names the lens",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the scanned code, a detector or a surface changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a detector that resolves to no record, or a surface that names an unknown lens",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a lens is a way of reading structure; its detectors read source, not a running system",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface whose lens does not exist, another plants a detector that resolves to no record, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The lens list and the algorithm records, which a surface and a detector cite",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-lens-meaning",
            "title": "meaning"
          },
          {
            "blocks": [
              {
                "items": [
                  "Nature: cause",
                  "Universal axis: [interaction](/records/reasoning/universal-axis-interaction)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "What produces what?",
                    "term": "Question"
                  },
                  {
                    "description": "mathematical-modeling",
                    "term": "Fields"
                  },
                  {
                    "description": "causal_duplication",
                    "term": "Surfaces"
                  },
                  {
                    "description": "[Causal Wiring Duplication](/records/algorithms/causal-wiring-duplication)",
                    "term": "Detectors"
                  },
                  {
                    "description": "[security-correctness](/records/reasoning/test-surface-security-correctness)",
                    "term": "Test surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the detectors each lens names, which resolve to algorithms records and scan code for the lens's duplication shapes, the test-surface catalog, which pairs each lens with a dimension",
                    "term": "Checked by"
                  },
                  {
                    "description": "The code the lens's detectors scan, and every surface that names the lens",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the scanned code, a detector or a surface changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a detector that resolves to no record, or a surface that names an unknown lens",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a lens is a way of reading structure; its detectors read source, not a running system",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface whose lens does not exist, another plants a detector that resolves to no record, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The lens list and the algorithm records, which a surface and a detector cite",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-lens-cause",
            "title": "cause"
          },
          {
            "blocks": [
              {
                "items": [
                  "Nature: expectation",
                  "Universal axis: [abstraction](/records/reasoning/universal-axis-abstraction)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "What usually follows?",
                    "term": "Question"
                  },
                  {
                    "description": "applied-mathematics",
                    "term": "Fields"
                  },
                  {
                    "description": "none",
                    "term": "Surfaces"
                  },
                  {
                    "description": "none",
                    "term": "Detectors"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the detectors each lens names, which resolve to algorithms records and scan code for the lens's duplication shapes, the test-surface catalog, which pairs each lens with a dimension",
                    "term": "Checked by"
                  },
                  {
                    "description": "The code the lens's detectors scan, and every surface that names the lens",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the scanned code, a detector or a surface changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a detector that resolves to no record, or a surface that names an unknown lens",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a lens is a way of reading structure; its detectors read source, not a running system",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface whose lens does not exist, another plants a detector that resolves to no record, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The lens list and the algorithm records, which a surface and a detector cite",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-lens-prediction",
            "title": "prediction"
          },
          {
            "blocks": [
              {
                "items": [
                  "Nature: exception",
                  "Universal axis: [abstraction](/records/reasoning/universal-axis-abstraction)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "What breaks the normal pattern?",
                    "term": "Question"
                  },
                  {
                    "description": "statistics",
                    "term": "Fields"
                  },
                  {
                    "description": "behavioral_inconsistency",
                    "term": "Surfaces"
                  },
                  {
                    "description": "[Anomaly Outlier Detection](/records/algorithms/anomaly-outlier-detection)",
                    "term": "Detectors"
                  },
                  {
                    "description": "[reliability-correctness](/records/reasoning/test-surface-reliability-correctness), [numerical-correctness](/records/reasoning/test-surface-numerical-correctness), [determinism-correctness](/records/reasoning/test-surface-determinism-correctness)",
                    "term": "Test surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the detectors each lens names, which resolve to algorithms records and scan code for the lens's duplication shapes, the test-surface catalog, which pairs each lens with a dimension",
                    "term": "Checked by"
                  },
                  {
                    "description": "The code the lens's detectors scan, and every surface that names the lens",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the scanned code, a detector or a surface changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a detector that resolves to no record, or a surface that names an unknown lens",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a lens is a way of reading structure; its detectors read source, not a running system",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface whose lens does not exist, another plants a detector that resolves to no record, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The lens list and the algorithm records, which a surface and a detector cite",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-lens-anomaly",
            "title": "anomaly"
          },
          {
            "blocks": [
              {
                "items": [
                  "Nature: development",
                  "Universal axis: [dynamics](/records/reasoning/universal-axis-dynamics)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "How does the pattern itself change?",
                    "term": "Question"
                  },
                  {
                    "description": "dynamical-systems",
                    "term": "Fields"
                  },
                  {
                    "description": "none",
                    "term": "Surfaces"
                  },
                  {
                    "description": "none",
                    "term": "Detectors"
                  },
                  {
                    "description": "[memory-correctness](/records/reasoning/test-surface-memory-correctness)",
                    "term": "Test surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the detectors each lens names, which resolve to algorithms records and scan code for the lens's duplication shapes, the test-surface catalog, which pairs each lens with a dimension",
                    "term": "Checked by"
                  },
                  {
                    "description": "The code the lens's detectors scan, and every surface that names the lens",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the scanned code, a detector or a surface changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a detector that resolves to no record, or a surface that names an unknown lens",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a lens is a way of reading structure; its detectors read source, not a running system",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface whose lens does not exist, another plants a detector that resolves to no record, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The lens list and the algorithm records, which a surface and a detector cite",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-lens-change",
            "title": "change"
          },
          {
            "blocks": [
              {
                "items": [
                  "Nature: self-similarity",
                  "Universal axis: [abstraction](/records/reasoning/universal-axis-abstraction)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Does the same structure recur at different scales?",
                    "term": "Question"
                  },
                  {
                    "description": "fractal-geometry, renormalization",
                    "term": "Fields"
                  },
                  {
                    "description": "scale_duplication",
                    "term": "Surfaces"
                  },
                  {
                    "description": "[Fractal Scale Duplication](/records/algorithms/fractal-scale-duplication)",
                    "term": "Detectors"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the detectors each lens names, which resolve to algorithms records and scan code for the lens's duplication shapes, the test-surface catalog, which pairs each lens with a dimension",
                    "term": "Checked by"
                  },
                  {
                    "description": "The code the lens's detectors scan, and every surface that names the lens",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the scanned code, a detector or a surface changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a detector that resolves to no record, or a surface that names an unknown lens",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a lens is a way of reading structure; its detectors read source, not a running system",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface whose lens does not exist, another plants a detector that resolves to no record, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The lens list and the algorithm records, which a surface and a detector cite",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-lens-fractal",
            "title": "fractal"
          },
          {
            "blocks": [
              {
                "items": [
                  "Nature: transformation",
                  "Universal axis: [dynamics](/records/reasoning/universal-axis-dynamics)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "How does one state become another?",
                    "term": "Question"
                  },
                  {
                    "description": "[algebra](/records/reasoning/math-domain-algebra), [computation](/records/reasoning/math-domain-computation)",
                    "term": "Fields"
                  },
                  {
                    "description": "none",
                    "term": "Surfaces"
                  },
                  {
                    "description": "none",
                    "term": "Detectors"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the detectors each lens names, which resolve to algorithms records and scan code for the lens's duplication shapes, the test-surface catalog, which pairs each lens with a dimension",
                    "term": "Checked by"
                  },
                  {
                    "description": "The code the lens's detectors scan, and every surface that names the lens",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the scanned code, a detector or a surface changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a detector that resolves to no record, or a surface that names an unknown lens",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a lens is a way of reading structure; its detectors read source, not a running system",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface whose lens does not exist, another plants a detector that resolves to no record, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The lens list and the algorithm records, which a surface and a detector cite",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-lens-transformation",
            "title": "transformation"
          },
          {
            "blocks": [
              {
                "items": [
                  "Nature: invariance",
                  "Universal axis: [arrangement](/records/reasoning/universal-axis-arrangement)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "What remains unchanged?",
                    "term": "Question"
                  },
                  {
                    "description": "[topology](/records/reasoning/math-domain-topology), symmetry",
                    "term": "Fields"
                  },
                  {
                    "description": "none",
                    "term": "Surfaces"
                  },
                  {
                    "description": "none",
                    "term": "Detectors"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the detectors each lens names, which resolve to algorithms records and scan code for the lens's duplication shapes, the test-surface catalog, which pairs each lens with a dimension",
                    "term": "Checked by"
                  },
                  {
                    "description": "The code the lens's detectors scan, and every surface that names the lens",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the scanned code, a detector or a surface changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a detector that resolves to no record, or a surface that names an unknown lens",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a lens is a way of reading structure; its detectors read source, not a running system",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface whose lens does not exist, another plants a detector that resolves to no record, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The lens list and the algorithm records, which a surface and a detector cite",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-lens-invariant",
            "title": "invariant"
          },
          {
            "blocks": [
              {
                "items": [
                  "Nature: selection",
                  "Universal axis: [abstraction](/records/reasoning/universal-axis-abstraction)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "What is the best possible state?",
                    "term": "Question"
                  },
                  {
                    "description": "operations-research",
                    "term": "Fields"
                  },
                  {
                    "description": "none",
                    "term": "Surfaces"
                  },
                  {
                    "description": "none",
                    "term": "Detectors"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the detectors each lens names, which resolve to algorithms records and scan code for the lens's duplication shapes, the test-surface catalog, which pairs each lens with a dimension",
                    "term": "Checked by"
                  },
                  {
                    "description": "The code the lens's detectors scan, and every surface that names the lens",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the scanned code, a detector or a surface changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a detector that resolves to no record, or a surface that names an unknown lens",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a lens is a way of reading structure; its detectors read source, not a running system",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface whose lens does not exist, another plants a detector that resolves to no record, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The lens list and the algorithm records, which a surface and a detector cite",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-lens-optimization",
            "title": "optimization"
          },
          {
            "blocks": [
              {
                "items": [
                  "Nature: difficulty",
                  "Universal axis: [abstraction](/records/reasoning/universal-axis-abstraction)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "How difficult is the transformation?",
                    "term": "Question"
                  },
                  {
                    "description": "computation-theory",
                    "term": "Fields"
                  },
                  {
                    "description": "none",
                    "term": "Surfaces"
                  },
                  {
                    "description": "none",
                    "term": "Detectors"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the detectors each lens names, which resolve to algorithms records and scan code for the lens's duplication shapes, the test-surface catalog, which pairs each lens with a dimension",
                    "term": "Checked by"
                  },
                  {
                    "description": "The code the lens's detectors scan, and every surface that names the lens",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the scanned code, a detector or a surface changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a detector that resolves to no record, or a surface that names an unknown lens",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a lens is a way of reading structure; its detectors read source, not a running system",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface whose lens does not exist, another plants a detector that resolves to no record, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The lens list and the algorithm records, which a surface and a detector cite",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-lens-complexity",
            "title": "complexity"
          }
        ],
        "title": "The lenses"
      },
      {
        "icon": "bi-signpost-split",
        "id": "the-modes",
        "intro": "Each reasoning mode is listed with the practice it names and the techniques that work in it.",
        "subsections": [
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "identifying patterns or examples",
                    "term": "Mode"
                  },
                  {
                    "description": "What is there?",
                    "term": "Question"
                  },
                  {
                    "description": "[static-analysis](/records/reasoning/technique-static-analysis), [runtime-validation](/records/reasoning/technique-runtime-validation), [profiling](/records/reasoning/technique-profiling), [heap-analysis](/records/reasoning/technique-heap-analysis), [monitoring](/records/reasoning/technique-monitoring)",
                    "term": "Techniques"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over the techniques, nodes and structured-document constructs that name the mode, the model-step check for every model whose steps are modes",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every technique, node, model step and document construct that names the mode",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the mode list or a record that names a mode changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a technique, node, model step or construct that names a mode that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a mode is a way of reasoning, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a technique whose mode does not exist, and the bundled records validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The mode list, which every technique, node, step and construct that names a mode cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-mode-observation",
            "title": "observation"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "defining objects",
                    "term": "Mode"
                  },
                  {
                    "description": "How can it be characterized?",
                    "term": "Question"
                  },
                  {
                    "description": "[tracing](/records/reasoning/technique-tracing)",
                    "term": "Techniques"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over the techniques, nodes and structured-document constructs that name the mode, the model-step check for every model whose steps are modes",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every technique, node, model step and document construct that names the mode",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the mode list or a record that names a mode changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a technique, node, model step or construct that names a mode that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a mode is a way of reasoning, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a technique whose mode does not exist, and the bundled records validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The mode list, which every technique, node, step and construct that names a mode cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-mode-description",
            "title": "description"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "finding similarities and differences",
                    "term": "Mode"
                  },
                  {
                    "description": "How is it similar or different?",
                    "term": "Question"
                  },
                  {
                    "description": "[unit-testing](/records/reasoning/technique-unit-testing), [integration-testing](/records/reasoning/technique-integration-testing), [end-to-end-testing](/records/reasoning/technique-end-to-end-testing), [differential-testing](/records/reasoning/technique-differential-testing), [contract-testing](/records/reasoning/technique-contract-testing), [assertion-checking](/records/reasoning/technique-assertion-checking), [read-after-write-verification](/records/reasoning/technique-read-after-write-verification)",
                    "term": "Techniques"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over the techniques, nodes and structured-document constructs that name the mode, the model-step check for every model whose steps are modes",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every technique, node, model step and document construct that names the mode",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the mode list or a record that names a mode changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a technique, node, model step or construct that names a mode that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a mode is a way of reasoning, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a technique whose mode does not exist, and the bundled records validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The mode list, which every technique, node, step and construct that names a mode cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-mode-comparison",
            "title": "comparison"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "grouping by properties",
                    "term": "Mode"
                  },
                  {
                    "description": "Which kind is it?",
                    "term": "Question"
                  },
                  {
                    "description": "[property-based-testing](/records/reasoning/technique-property-based-testing)",
                    "term": "Techniques"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over the techniques, nodes and structured-document constructs that name the mode, the model-step check for every model whose steps are modes",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every technique, node, model step and document construct that names the mode",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the mode list or a record that names a mode changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a technique, node, model step or construct that names a mode that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a mode is a way of reasoning, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a technique whose mode does not exist, and the bundled records validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The mode list, which every technique, node, step and construct that names a mode cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-mode-classification",
            "title": "classification"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "removing irrelevant details",
                    "term": "Mode"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over the techniques, nodes and structured-document constructs that name the mode, the model-step check for every model whose steps are modes",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every technique, node, model step and document construct that names the mode",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the mode list or a record that names a mode changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a technique, node, model step or construct that names a mode that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a mode is a way of reasoning, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a technique whose mode does not exist, and the bundled records validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The mode list, which every technique, node, step and construct that names a mode cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-mode-abstraction",
            "title": "abstraction"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "extending examples into principles",
                    "term": "Mode"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over the techniques, nodes and structured-document constructs that name the mode, the model-step check for every model whose steps are modes",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every technique, node, model step and document construct that names the mode",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the mode list or a record that names a mode changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a technique, node, model step or construct that names a mode that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a mode is a way of reasoning, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a technique whose mode does not exist, and the bundled records validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The mode list, which every technique, node, step and construct that names a mode cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-mode-generalization",
            "title": "generalization"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "expressing ideas symbolically",
                    "term": "Mode"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over the techniques, nodes and structured-document constructs that name the mode, the model-step check for every model whose steps are modes",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every technique, node, model step and document construct that names the mode",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the mode list or a record that names a mode changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a technique, node, model step or construct that names a mode that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a mode is a way of reasoning, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a technique whose mode does not exist, and the bundled records validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The mode list, which every technique, node, step and construct that names a mode cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-mode-formalization",
            "title": "formalization"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "identifying mechanisms",
                    "term": "Mode"
                  },
                  {
                    "description": "Why is it this way?",
                    "term": "Question"
                  },
                  {
                    "description": "[model-checking](/records/reasoning/technique-model-checking)",
                    "term": "Techniques"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over the techniques, nodes and structured-document constructs that name the mode, the model-step check for every model whose steps are modes",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every technique, node, model step and document construct that names the mode",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the mode list or a record that names a mode changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a technique, node, model step or construct that names a mode that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a mode is a way of reasoning, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a technique whose mode does not exist, and the bundled records validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The mode list, which every technique, node, step and construct that names a mode cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-mode-explanation",
            "title": "explanation"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "deriving necessary consequences",
                    "term": "Mode"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over the techniques, nodes and structured-document constructs that name the mode, the model-step check for every model whose steps are modes",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every technique, node, model step and document construct that names the mode",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the mode list or a record that names a mode changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a technique, node, model step or construct that names a mode that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a mode is a way of reasoning, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a technique whose mode does not exist, and the bundled records validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The mode list, which every technique, node, step and construct that names a mode cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-mode-deduction",
            "title": "deduction"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "building objects that satisfy rules",
                    "term": "Mode"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over the techniques, nodes and structured-document constructs that name the mode, the model-step check for every model whose steps are modes",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every technique, node, model step and document construct that names the mode",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the mode list or a record that names a mode changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a technique, node, model step or construct that names a mode that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a mode is a way of reasoning, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a technique whose mode does not exist, and the bundled records validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The mode list, which every technique, node, step and construct that names a mode cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-mode-construction",
            "title": "construction"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "establishing certainty",
                    "term": "Mode"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over the techniques, nodes and structured-document constructs that name the mode, the model-step check for every model whose steps are modes",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every technique, node, model step and document construct that names the mode",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the mode list or a record that names a mode changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a technique, node, model step or construct that names a mode that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a mode is a way of reasoning, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a technique whose mode does not exist, and the bundled records validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The mode list, which every technique, node, step and construct that names a mode cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-mode-proof",
            "title": "proof"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "inferring future states",
                    "term": "Mode"
                  },
                  {
                    "description": "What comes next?",
                    "term": "Question"
                  },
                  {
                    "description": "[load-testing](/records/reasoning/technique-load-testing), [stress-testing](/records/reasoning/technique-stress-testing)",
                    "term": "Techniques"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over the techniques, nodes and structured-document constructs that name the mode, the model-step check for every model whose steps are modes",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every technique, node, model step and document construct that names the mode",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the mode list or a record that names a mode changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a technique, node, model step or construct that names a mode that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a mode is a way of reasoning, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a technique whose mode does not exist, and the bundled records validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The mode list, which every technique, node, step and construct that names a mode cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-mode-prediction",
            "title": "prediction"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "selecting preferred solutions",
                    "term": "Mode"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over the techniques, nodes and structured-document constructs that name the mode, the model-step check for every model whose steps are modes",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every technique, node, model step and document construct that names the mode",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the mode list or a record that names a mode changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a technique, node, model step or construct that names a mode that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a mode is a way of reasoning, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a technique whose mode does not exist, and the bundled records validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The mode list, which every technique, node, step and construct that names a mode cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-mode-optimization",
            "title": "optimization"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "modifying systems",
                    "term": "Mode"
                  },
                  {
                    "description": "How can it be changed?",
                    "term": "Question"
                  },
                  {
                    "description": "[fault-injection](/records/reasoning/technique-fault-injection), [chaos-testing](/records/reasoning/technique-chaos-testing), [mutation-testing](/records/reasoning/technique-mutation-testing)",
                    "term": "Techniques"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over the techniques, nodes and structured-document constructs that name the mode, the model-step check for every model whose steps are modes",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every technique, node, model step and document construct that names the mode",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the mode list or a record that names a mode changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a technique, node, model step or construct that names a mode that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a mode is a way of reasoning, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a technique whose mode does not exist, and the bundled records validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The mode list, which every technique, node, step and construct that names a mode cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-mode-intervention",
            "title": "intervention"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "generating new structures",
                    "term": "Mode"
                  },
                  {
                    "description": "Can new examples be produced?",
                    "term": "Question"
                  },
                  {
                    "description": "[fuzz-testing](/records/reasoning/technique-fuzz-testing)",
                    "term": "Techniques"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over the techniques, nodes and structured-document constructs that name the mode, the model-step check for every model whose steps are modes",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every technique, node, model step and document construct that names the mode",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the mode list or a record that names a mode changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a technique, node, model step or construct that names a mode that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a mode is a way of reasoning, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a technique whose mode does not exist, and the bundled records validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The mode list, which every technique, node, step and construct that names a mode cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-mode-creation",
            "title": "creation"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "discovering the principles behind the examples",
                    "term": "Mode"
                  },
                  {
                    "description": "What general principles emerge?",
                    "term": "Question"
                  },
                  {
                    "description": "[deterministic-replay](/records/reasoning/technique-deterministic-replay)",
                    "term": "Techniques"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over the techniques, nodes and structured-document constructs that name the mode, the model-step check for every model whose steps are modes",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every technique, node, model step and document construct that names the mode",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the mode list or a record that names a mode changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a technique, node, model step or construct that names a mode that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a mode is a way of reasoning, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a technique whose mode does not exist, and the bundled records validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The mode list, which every technique, node, step and construct that names a mode cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-mode-reflection",
            "title": "reflection"
          }
        ],
        "title": "The modes"
      },
      {
        "icon": "bi-signpost-split",
        "id": "the-representations",
        "intro": "A result can be encoded in any of these representation layers.",
        "subsections": [
          {
            "blocks": [
              {
                "kind": "text",
                "text": "equations, formulas, notation"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over the nodes and structured-document constructs that name the representation",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every node and document construct that names the representation",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the representations or a record that names one changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a node or construct that names a representation that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a representation is a form of encoding, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a node that names a missing representation, and the bundled references resolve",
                    "term": "Evidence"
                  },
                  {
                    "description": "The representation list, which every node and construct that names a representation cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-representation-symbolic",
            "title": "symbolic"
          },
          {
            "blocks": [
              {
                "kind": "text",
                "text": "statements, predicates, proofs"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over the nodes and structured-document constructs that name the representation",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every node and document construct that names the representation",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the representations or a record that names one changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a node or construct that names a representation that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a representation is a form of encoding, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a node that names a missing representation, and the bundled references resolve",
                    "term": "Evidence"
                  },
                  {
                    "description": "The representation list, which every node and construct that names a representation cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-representation-logic",
            "title": "logical"
          },
          {
            "blocks": [
              {
                "kind": "text",
                "text": "numbers, quantities, measurements"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over the nodes and structured-document constructs that name the representation",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every node and document construct that names the representation",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the representations or a record that names one changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a node or construct that names a representation that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a representation is a form of encoding, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a node that names a missing representation, and the bundled references resolve",
                    "term": "Evidence"
                  },
                  {
                    "description": "The representation list, which every node and construct that names a representation cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-representation-number",
            "title": "numerical"
          },
          {
            "blocks": [
              {
                "kind": "text",
                "text": "operations, groups, fields"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over the nodes and structured-document constructs that name the representation",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every node and document construct that names the representation",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the representations or a record that names one changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a node or construct that names a representation that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a representation is a form of encoding, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a node that names a missing representation, and the bundled references resolve",
                    "term": "Evidence"
                  },
                  {
                    "description": "The representation list, which every node and construct that names a representation cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-representation-algebra",
            "title": "algebraic"
          },
          {
            "blocks": [
              {
                "kind": "text",
                "text": "shapes, coordinates, spaces"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over the nodes and structured-document constructs that name the representation",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every node and document construct that names the representation",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the representations or a record that names one changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a node or construct that names a representation that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a representation is a form of encoding, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a node that names a missing representation, and the bundled references resolve",
                    "term": "Evidence"
                  },
                  {
                    "description": "The representation list, which every node and construct that names a representation cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-representation-geometry",
            "title": "geometric"
          },
          {
            "blocks": [
              {
                "kind": "text",
                "text": "connectivity, continuity"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over the nodes and structured-document constructs that name the representation",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every node and document construct that names the representation",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the representations or a record that names one changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a node or construct that names a representation that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a representation is a form of encoding, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a node that names a missing representation, and the bundled references resolve",
                    "term": "Evidence"
                  },
                  {
                    "description": "The representation list, which every node and construct that names a representation cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-representation-topology",
            "title": "topological"
          },
          {
            "blocks": [
              {
                "kind": "text",
                "text": "diagrams, graphs, networks"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over the nodes and structured-document constructs that name the representation",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every node and document construct that names the representation",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the representations or a record that names one changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a node or construct that names a representation that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a representation is a form of encoding, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a node that names a missing representation, and the bundled references resolve",
                    "term": "Evidence"
                  },
                  {
                    "description": "The representation list, which every node and construct that names a representation cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-representation-graph",
            "title": "graphical"
          },
          {
            "blocks": [
              {
                "kind": "text",
                "text": "linear transformations"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over the nodes and structured-document constructs that name the representation",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every node and document construct that names the representation",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the representations or a record that names one changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a node or construct that names a representation that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a representation is a form of encoding, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a node that names a missing representation, and the bundled references resolve",
                    "term": "Evidence"
                  },
                  {
                    "description": "The representation list, which every node and construct that names a representation cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-representation-matrix",
            "title": "matrix"
          },
          {
            "blocks": [
              {
                "kind": "text",
                "text": "mappings between spaces"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over the nodes and structured-document constructs that name the representation",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every node and document construct that names the representation",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the representations or a record that names one changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a node or construct that names a representation that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a representation is a form of encoding, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a node that names a missing representation, and the bundled references resolve",
                    "term": "Evidence"
                  },
                  {
                    "description": "The representation list, which every node and construct that names a representation cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-representation-function",
            "title": "functional"
          },
          {
            "blocks": [
              {
                "kind": "text",
                "text": "entropy, encoding, compression"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over the nodes and structured-document constructs that name the representation",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every node and document construct that names the representation",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the representations or a record that names one changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a node or construct that names a representation that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a representation is a form of encoding, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a node that names a missing representation, and the bundled references resolve",
                    "term": "Evidence"
                  },
                  {
                    "description": "The representation list, which every node and construct that names a representation cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-representation-information-theory",
            "title": "information-theoretic"
          },
          {
            "blocks": [
              {
                "kind": "text",
                "text": "distributions and likelihoods"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over the nodes and structured-document constructs that name the representation",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every node and document construct that names the representation",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the representations or a record that names one changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a node or construct that names a representation that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a representation is a form of encoding, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a node that names a missing representation, and the bundled references resolve",
                    "term": "Evidence"
                  },
                  {
                    "description": "The representation list, which every node and construct that names a representation cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-representation-probability",
            "title": "probabilistic"
          },
          {
            "blocks": [
              {
                "kind": "text",
                "text": "state transitions"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over the nodes and structured-document constructs that name the representation",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every node and document construct that names the representation",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the representations or a record that names one changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a node or construct that names a representation that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a representation is a form of encoding, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a node that names a missing representation, and the bundled references resolve",
                    "term": "Evidence"
                  },
                  {
                    "description": "The representation list, which every node and construct that names a representation cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-representation-dynamical-systems",
            "title": "dynamical"
          },
          {
            "blocks": [
              {
                "kind": "text",
                "text": "algorithms and programs"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over the nodes and structured-document constructs that name the representation",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every node and document construct that names the representation",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the representations or a record that names one changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a node or construct that names a representation that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a representation is a form of encoding, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a node that names a missing representation, and the bundled references resolve",
                    "term": "Evidence"
                  },
                  {
                    "description": "The representation list, which every node and construct that names a representation cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-representation-computation",
            "title": "computational"
          },
          {
            "blocks": [
              {
                "kind": "text",
                "text": "objects and morphisms"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over the nodes and structured-document constructs that name the representation",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every node and document construct that names the representation",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the representations or a record that names one changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a node or construct that names a representation that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a representation is a form of encoding, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a node that names a missing representation, and the bundled references resolve",
                    "term": "Evidence"
                  },
                  {
                    "description": "The representation list, which every node and construct that names a representation cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-representation-category-theory",
            "title": "categorical"
          }
        ],
        "title": "The representations"
      },
      {
        "icon": "bi-signpost-split",
        "id": "the-pattern-types",
        "intro": "Each pattern type is listed with the mathematical viewpoint it takes.",
        "subsections": [
          {
            "blocks": [
              {
                "kind": "text",
                "text": "formal systems and equations"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over every ground that names the pattern type",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every construct and record that grounds the pattern type",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the pattern types or a record that names one changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a ground that names a pattern type that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a pattern type is a viewpoint on structure, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a ground whose kind exists and whose id does not, and a ground filed under the wrong kind, and passes a well-formed one",
                    "term": "Evidence"
                  },
                  {
                    "description": "The pattern type list, which every ground that names a type cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-pattern-type-symbolic",
            "title": "symbolic"
          },
          {
            "blocks": [
              {
                "kind": "text",
                "text": "quantity and arithmetic"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over every ground that names the pattern type",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every construct and record that grounds the pattern type",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the pattern types or a record that names one changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a ground that names a pattern type that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a pattern type is a viewpoint on structure, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a ground whose kind exists and whose id does not, and a ground filed under the wrong kind, and passes a well-formed one",
                    "term": "Evidence"
                  },
                  {
                    "description": "The pattern type list, which every ground that names a type cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-pattern-type-number",
            "title": "numerical"
          },
          {
            "blocks": [
              {
                "kind": "text",
                "text": "operations and transformations"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over every ground that names the pattern type",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every construct and record that grounds the pattern type",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the pattern types or a record that names one changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a ground that names a pattern type that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a pattern type is a viewpoint on structure, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a ground whose kind exists and whose id does not, and a ground filed under the wrong kind, and passes a well-formed one",
                    "term": "Evidence"
                  },
                  {
                    "description": "The pattern type list, which every ground that names a type cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-pattern-type-algebra",
            "title": "algebraic"
          },
          {
            "blocks": [
              {
                "kind": "text",
                "text": "shape and space"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over every ground that names the pattern type",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every construct and record that grounds the pattern type",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the pattern types or a record that names one changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a ground that names a pattern type that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a pattern type is a viewpoint on structure, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a ground whose kind exists and whose id does not, and a ground filed under the wrong kind, and passes a well-formed one",
                    "term": "Evidence"
                  },
                  {
                    "description": "The pattern type list, which every ground that names a type cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-pattern-type-geometry",
            "title": "geometric"
          },
          {
            "blocks": [
              {
                "kind": "text",
                "text": "connectivity and invariance"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over every ground that names the pattern type",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every construct and record that grounds the pattern type",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the pattern types or a record that names one changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a ground that names a pattern type that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a pattern type is a viewpoint on structure, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a ground whose kind exists and whose id does not, and a ground filed under the wrong kind, and passes a well-formed one",
                    "term": "Evidence"
                  },
                  {
                    "description": "The pattern type list, which every ground that names a type cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-pattern-type-topology",
            "title": "topological"
          },
          {
            "blocks": [
              {
                "kind": "text",
                "text": "truth and implication"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over every ground that names the pattern type",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every construct and record that grounds the pattern type",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the pattern types or a record that names one changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a ground that names a pattern type that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a pattern type is a viewpoint on structure, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a ground whose kind exists and whose id does not, and a ground filed under the wrong kind, and passes a well-formed one",
                    "term": "Evidence"
                  },
                  {
                    "description": "The pattern type list, which every ground that names a type cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-pattern-type-logic",
            "title": "logical"
          },
          {
            "blocks": [
              {
                "kind": "text",
                "text": "possible arrangements"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over every ground that names the pattern type",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every construct and record that grounds the pattern type",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the pattern types or a record that names one changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a ground that names a pattern type that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a pattern type is a viewpoint on structure, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a ground whose kind exists and whose id does not, and a ground filed under the wrong kind, and passes a well-formed one",
                    "term": "Evidence"
                  },
                  {
                    "description": "The pattern type list, which every ground that names a type cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-pattern-type-combinatorics",
            "title": "combinatorial"
          },
          {
            "blocks": [
              {
                "kind": "text",
                "text": "distribution and variation"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over every ground that names the pattern type",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every construct and record that grounds the pattern type",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the pattern types or a record that names one changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a ground that names a pattern type that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a pattern type is a viewpoint on structure, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a ground whose kind exists and whose id does not, and a ground filed under the wrong kind, and passes a well-formed one",
                    "term": "Evidence"
                  },
                  {
                    "description": "The pattern type list, which every ground that names a type cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-pattern-type-statistical",
            "title": "statistical"
          },
          {
            "blocks": [
              {
                "kind": "text",
                "text": "randomness and uncertainty"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over every ground that names the pattern type",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every construct and record that grounds the pattern type",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the pattern types or a record that names one changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a ground that names a pattern type that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a pattern type is a viewpoint on structure, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a ground whose kind exists and whose id does not, and a ground filed under the wrong kind, and passes a well-formed one",
                    "term": "Evidence"
                  },
                  {
                    "description": "The pattern type list, which every ground that names a type cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-pattern-type-probability",
            "title": "probabilistic"
          },
          {
            "blocks": [
              {
                "kind": "text",
                "text": "compression and complexity"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over every ground that names the pattern type",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every construct and record that grounds the pattern type",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the pattern types or a record that names one changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a ground that names a pattern type that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a pattern type is a viewpoint on structure, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a ground whose kind exists and whose id does not, and a ground filed under the wrong kind, and passes a well-formed one",
                    "term": "Evidence"
                  },
                  {
                    "description": "The pattern type list, which every ground that names a type cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-pattern-type-information",
            "title": "information"
          },
          {
            "blocks": [
              {
                "kind": "text",
                "text": "change over time"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over every ground that names the pattern type",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every construct and record that grounds the pattern type",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the pattern types or a record that names one changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a ground that names a pattern type that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a pattern type is a viewpoint on structure, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a ground whose kind exists and whose id does not, and a ground filed under the wrong kind, and passes a well-formed one",
                    "term": "Evidence"
                  },
                  {
                    "description": "The pattern type list, which every ground that names a type cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-pattern-type-dynamical-systems",
            "title": "dynamical"
          },
          {
            "blocks": [
              {
                "kind": "text",
                "text": "procedures and algorithms"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over every ground that names the pattern type",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every construct and record that grounds the pattern type",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the pattern types or a record that names one changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a ground that names a pattern type that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a pattern type is a viewpoint on structure, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a ground whose kind exists and whose id does not, and a ground filed under the wrong kind, and passes a well-formed one",
                    "term": "Evidence"
                  },
                  {
                    "description": "The pattern type list, which every ground that names a type cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-pattern-type-computation",
            "title": "computational"
          },
          {
            "blocks": [
              {
                "kind": "text",
                "text": "relationships between structures"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over every ground that names the pattern type",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every construct and record that grounds the pattern type",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the pattern types or a record that names one changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a ground that names a pattern type that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a pattern type is a viewpoint on structure, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a ground whose kind exists and whose id does not, and a ground filed under the wrong kind, and passes a well-formed one",
                    "term": "Evidence"
                  },
                  {
                    "description": "The pattern type list, which every ground that names a type cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-pattern-type-category-theory",
            "title": "categorical"
          },
          {
            "blocks": [
              {
                "kind": "text",
                "text": "recursive self-similarity"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate over every ground that names the pattern type",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every construct and record that grounds the pattern type",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the pattern types or a record that names one changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a ground that names a pattern type that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a pattern type is a viewpoint on structure, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a ground whose kind exists and whose id does not, and a ground filed under the wrong kind, and passes a well-formed one",
                    "term": "Evidence"
                  },
                  {
                    "description": "The pattern type list, which every ground that names a type cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-pattern-type-fractal",
            "title": "fractal"
          }
        ],
        "title": "The pattern types"
      },
      {
        "icon": "bi-signpost-split",
        "id": "the-models",
        "intro": "The models are sequences that restate the same cycle from different starting points.",
        "subsections": [
          {
            "blocks": [
              {
                "items": [
                  "Question: How does a pattern come to be?",
                  "Recursion: emergence → difference"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "[existence](/records/reasoning/substrate-node-existence) → [difference](/records/reasoning/substrate-node-difference) → [relation](/records/reasoning/substrate-node-relation) → [structure](/records/reasoning/substrate-node-structure) → [transformation](/records/reasoning/substrate-node-transformation) → [constraint](/records/reasoning/substrate-node-constraint) → [emergence](/records/reasoning/substrate-node-emergence)",
                    "term": "Sequence"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the model-step check, which holds every step to the model's declared step kind, the document-type check, which requires every structured document type to name a model",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every model, its steps, and every document type that names it",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the model, its step kind or a document type that names it changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a step outside the declared kind, or a document type whose model does not resolve",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a model is a sequence of reasoning steps, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a step outside the model's step kind, another plants a document type whose model does not resolve, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The model's declared step kind, which each step conforms to, and the model, which a document type cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-model-ontogenesis",
            "title": "ontogenesis"
          },
          {
            "blocks": [
              {
                "items": [
                  "Question: How is a pattern known?"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "[observation](/records/reasoning/mode-observation) → [description](/records/reasoning/mode-description) → [comparison](/records/reasoning/mode-comparison) → [classification](/records/reasoning/mode-classification) → [explanation](/records/reasoning/mode-explanation) → [prediction](/records/reasoning/mode-prediction) → [intervention](/records/reasoning/mode-intervention) → [creation](/records/reasoning/mode-creation) → [reflection](/records/reasoning/mode-reflection)",
                    "term": "Sequence"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the model-step check, which holds every step to the model's declared step kind, the document-type check, which requires every structured document type to name a model",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every model, its steps, and every document type that names it",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the model, its step kind or a document type that names it changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a step outside the declared kind, or a document type whose model does not resolve",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a model is a sequence of reasoning steps, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a step outside the model's step kind, another plants a document type whose model does not resolve, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The model's declared step kind, which each step conforms to, and the model, which a document type cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-model-epistemology",
            "title": "epistemology"
          },
          {
            "blocks": [
              {
                "items": [
                  "Question: How does a system perceive, act, and adapt?",
                  "Recursion: evolution → difference"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "existence → difference → relation → structure → transformation → constraint → emergence → representation → memory → prediction → action → feedback → evolution",
                    "term": "Sequence"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the model-step check, which holds every step to the model's declared step kind, the document-type check, which requires every structured document type to name a model",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every model, its steps, and every document type that names it",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the model, its step kind or a document type that names it changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a step outside the declared kind, or a document type whose model does not resolve",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a model is a sequence of reasoning steps, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a step outside the model's step kind, another plants a document type whose model does not resolve, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The model's declared step kind, which each step conforms to, and the model, which a document type cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-model-cognition",
            "title": "cognition"
          },
          {
            "blocks": [
              {
                "items": [
                  "Question: How does pattern-work proceed?",
                  "Recursion: create → exist"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "exist → differentiate → relate → organize → transform → constrain → stabilize → represent → reasoning → predict → create",
                    "term": "Sequence"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the model-step check, which holds every step to the model's declared step kind, the document-type check, which requires every structured document type to name a model",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every model, its steps, and every document type that names it",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the model, its step kind or a document type that names it changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a step outside the declared kind, or a document type whose model does not resolve",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a model is a sequence of reasoning steps, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a step outside the model's step kind, another plants a document type whose model does not resolve, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The model's declared step kind, which each step conforms to, and the model, which a document type cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-model-pattern-cycle",
            "title": "pattern-cycle"
          }
        ],
        "title": "The models"
      },
      {
        "icon": "bi-signpost-split",
        "id": "the-universal-axes",
        "intro": "The five universal axes are listed with the dimensions each one subsumes and the lenses that sit on it.",
        "subsections": [
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "What entities are present?",
                    "term": "Question"
                  },
                  {
                    "description": "[identity](/records/reasoning/dimension-identity)",
                    "term": "Subsumes"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate, which requires every lens to name a universal axis that exists",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every lens that names the universal axis",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the universal axes or a lens changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a lens that names a universal axis that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a universal axis groups lenses, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a lens whose universal axis does not exist, and the bundled lenses validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The universal axis list, which every lens cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-universal-axis-existence",
            "title": "existence"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "How are they organized?",
                    "term": "Question"
                  },
                  {
                    "description": "[structure](/records/reasoning/dimension-structure), [space](/records/reasoning/dimension-space)",
                    "term": "Subsumes"
                  },
                  {
                    "description": "[structural](/records/reasoning/lens-structure), [spatial](/records/reasoning/lens-space), [invariant](/records/reasoning/lens-invariant)",
                    "term": "Lenses"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate, which requires every lens to name a universal axis that exists",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every lens that names the universal axis",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the universal axes or a lens changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a lens that names a universal axis that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a universal axis groups lenses, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a lens whose universal axis does not exist, and the bundled lenses validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The universal axis list, which every lens cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-universal-axis-arrangement",
            "title": "arrangement"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "How do they change?",
                    "term": "Question"
                  },
                  {
                    "description": "[time](/records/reasoning/dimension-time), [change](/records/reasoning/dimension-change)",
                    "term": "Subsumes"
                  },
                  {
                    "description": "[temporal](/records/reasoning/lens-time), [frequency](/records/reasoning/lens-frequency), [sequential](/records/reasoning/lens-sequential), [evolutionary](/records/reasoning/lens-change), [transformational](/records/reasoning/lens-transformation)",
                    "term": "Lenses"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate, which requires every lens to name a universal axis that exists",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every lens that names the universal axis",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the universal axes or a lens changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a lens that names a universal axis that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a universal axis groups lenses, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a lens whose universal axis does not exist, and the bundled lenses validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The universal axis list, which every lens cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-universal-axis-dynamics",
            "title": "dynamics"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "How do they influence one another?",
                    "term": "Question"
                  },
                  {
                    "description": "[relation](/records/reasoning/dimension-relation), [behavior](/records/reasoning/dimension-behavior), [cause](/records/reasoning/dimension-cause)",
                    "term": "Subsumes"
                  },
                  {
                    "description": "[relational](/records/reasoning/lens-relation), [behavioral](/records/reasoning/lens-behavior), [causal](/records/reasoning/lens-cause)",
                    "term": "Lenses"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate, which requires every lens to name a universal axis that exists",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every lens that names the universal axis",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the universal axes or a lens changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a lens that names a universal axis that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a universal axis groups lenses, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a lens whose universal axis does not exist, and the bundled lenses validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The universal axis list, which every lens cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-universal-axis-interaction",
            "title": "interaction"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "What meaning or principle can be inferred?",
                    "term": "Question"
                  },
                  {
                    "description": "[meaning](/records/reasoning/dimension-meaning), [function](/records/reasoning/dimension-function), [probability](/records/reasoning/dimension-probability)",
                    "term": "Subsumes"
                  },
                  {
                    "description": "[statistical](/records/reasoning/lens-statistical), [functional](/records/reasoning/lens-function), [semantic](/records/reasoning/lens-meaning), [predictive](/records/reasoning/lens-prediction), [anomaly](/records/reasoning/lens-anomaly), [fractal](/records/reasoning/lens-fractal), [optimization](/records/reasoning/lens-optimization), [complexity](/records/reasoning/lens-complexity)",
                    "term": "Lenses"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the ontology resolution gate, which requires every lens to name a universal axis that exists",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every lens that names the universal axis",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the universal axes or a lens changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a lens that names a universal axis that does not exist",
                    "term": "Refusal"
                  },
                  {
                    "description": "None, because a universal axis groups lenses, and nothing observes it while a run executes",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a lens whose universal axis does not exist, and the bundled lenses validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The universal axis list, which every lens cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-universal-axis-abstraction",
            "title": "abstraction"
          }
        ],
        "title": "The universal axes"
      },
      {
        "icon": "bi-signpost-split",
        "id": "the-test-surfaces",
        "intro": "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](/software-architecture/coverage#what-can-drift-seen-through-how-it-drifts).",
        "subsections": [
          {
            "blocks": [
              {
                "items": [
                  "Dimension: [meaning](/records/reasoning/dimension-meaning)",
                  "Lens: [semantic](/records/reasoning/lens-meaning)",
                  "Invariant: [correct-outputs](/records/reasoning/invariant-correct-outputs)",
                  "Predicate: [equivalence](/records/vocabulary/predicate-type-equivalence)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "An output is correct when it signifies what the input asked for, so the surface compares the meaning of the result with the meaning expected.",
                    "term": "Fit"
                  },
                  {
                    "description": "wrong value, incorrect algorithm, wrong computation",
                    "term": "Failure modes"
                  },
                  {
                    "description": "[unit-testing](/records/reasoning/technique-unit-testing), [property-based-testing](/records/reasoning/technique-property-based-testing), [differential-testing](/records/reasoning/technique-differential-testing), [assertion-checking](/records/reasoning/technique-assertion-checking)",
                    "term": "Techniques"
                  },
                  {
                    "description": "[ver-ground-truth](/records/reasoning/node-ver-ground-truth)",
                    "term": "Predicate grounds"
                  },
                  {
                    "description": "[test-result](/records/vocabulary/evidence-source-test-result) · required",
                    "term": "Evidence"
                  },
                  {
                    "description": "[ver-evidence](/records/reasoning/node-ver-evidence)",
                    "term": "Evidence grounds"
                  },
                  {
                    "description": "[pass](/records/vocabulary/verdict-pass), [fail](/records/vocabulary/verdict-fail), [unknown](/records/vocabulary/verdict-unknown)",
                    "term": "Verdicts"
                  }
                ],
                "kind": "glossary"
              },
              {
                "code": "output(input) = expected(input)",
                "kind": "code",
                "language": "text",
                "title": "Predicate"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the techniques each surface lists, whose results the surface's predicate and evidence decide, the covered-surfaces check, which validates every surface a module declares covered",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every module that declares the surface covered, and the code under that module",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the module's code, its declaration or the surface changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The covered-surfaces check fails a module that declares an unknown surface; a surface whose evidence is empty stays unknown, never pass",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime techniques among the surface's list, which locate failures without certifying their absence",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a surface with no techniques, an empty verdict domain, a blank predicate and a colliding cell, and the bundled surfaces validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The evidence the surface's techniques produce, which the verdict is decided from, so an empty evidence set leaves it unknown",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-test-surface-semantic-correctness",
            "title": "semantic-correctness"
          },
          {
            "blocks": [
              {
                "items": [
                  "Dimension: [function](/records/reasoning/dimension-function)",
                  "Lens: [behavioral](/records/reasoning/lens-behavior)",
                  "Invariant: [correct-state-evolution](/records/reasoning/invariant-correct-state-evolution)",
                  "Predicate: [invariant](/records/vocabulary/predicate-type-invariant)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "A workflow fulfils its role through the actions it takes, so the surface reads the role from the transitions the system actually performs.",
                    "term": "Fit"
                  },
                  {
                    "description": "invalid workflow, missing transition, incorrect business rule",
                    "term": "Failure modes"
                  },
                  {
                    "description": "[integration-testing](/records/reasoning/technique-integration-testing), [model-checking](/records/reasoning/technique-model-checking)",
                    "term": "Techniques"
                  },
                  {
                    "description": "[ver-ground-truth](/records/reasoning/node-ver-ground-truth)",
                    "term": "Predicate grounds"
                  },
                  {
                    "description": "[test-result](/records/vocabulary/evidence-source-test-result) · required",
                    "term": "Evidence"
                  },
                  {
                    "description": "[ver-evidence](/records/reasoning/node-ver-evidence)",
                    "term": "Evidence grounds"
                  },
                  {
                    "description": "[pass](/records/vocabulary/verdict-pass), [fail](/records/vocabulary/verdict-fail), [unknown](/records/vocabulary/verdict-unknown)",
                    "term": "Verdicts"
                  }
                ],
                "kind": "glossary"
              },
              {
                "code": "transition in allowedTransitions",
                "kind": "code",
                "language": "text",
                "title": "Predicate"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the techniques each surface lists, whose results the surface's predicate and evidence decide, the covered-surfaces check, which validates every surface a module declares covered",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every module that declares the surface covered, and the code under that module",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the module's code, its declaration or the surface changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The covered-surfaces check fails a module that declares an unknown surface; a surface whose evidence is empty stays unknown, never pass",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime techniques among the surface's list, which locate failures without certifying their absence",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a surface with no techniques, an empty verdict domain, a blank predicate and a colliding cell, and the bundled surfaces validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The evidence the surface's techniques produce, which the verdict is decided from, so an empty evidence set leaves it unknown",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-test-surface-functional-correctness",
            "title": "functional-correctness"
          },
          {
            "blocks": [
              {
                "items": [
                  "Dimension: [state](/records/reasoning/dimension-state)",
                  "Lens: [sequential](/records/reasoning/lens-sequential)",
                  "Invariant: [valid-state-transitions](/records/reasoning/invariant-valid-state-transitions)",
                  "Predicate: [temporal-order](/records/vocabulary/predicate-type-temporal-order)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "A state is valid only relative to the one before it, so the surface checks conditions in the order they occur.",
                    "term": "Fit"
                  },
                  {
                    "description": "invalid state, broken state transitions, violated lifecycle rules",
                    "term": "Failure modes"
                  },
                  {
                    "description": "[assertion-checking](/records/reasoning/technique-assertion-checking), [property-based-testing](/records/reasoning/technique-property-based-testing)",
                    "term": "Techniques"
                  },
                  {
                    "description": "[ver-ground-truth](/records/reasoning/node-ver-ground-truth)",
                    "term": "Predicate grounds"
                  },
                  {
                    "description": "[test-result](/records/vocabulary/evidence-source-test-result) · required",
                    "term": "Evidence"
                  },
                  {
                    "description": "[ver-evidence](/records/reasoning/node-ver-evidence)",
                    "term": "Evidence grounds"
                  },
                  {
                    "description": "[pass](/records/vocabulary/verdict-pass), [fail](/records/vocabulary/verdict-fail), [unknown](/records/vocabulary/verdict-unknown)",
                    "term": "Verdicts"
                  }
                ],
                "kind": "glossary"
              },
              {
                "code": "state[t+1] in next(state[t])",
                "kind": "code",
                "language": "text",
                "title": "Predicate"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the techniques each surface lists, whose results the surface's predicate and evidence decide, the covered-surfaces check, which validates every surface a module declares covered",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every module that declares the surface covered, and the code under that module",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the module's code, its declaration or the surface changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The covered-surfaces check fails a module that declares an unknown surface; a surface whose evidence is empty stays unknown, never pass",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime techniques among the surface's list, which locate failures without certifying their absence",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a surface with no techniques, an empty verdict domain, a blank predicate and a colliding cell, and the bundled surfaces validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The evidence the surface's techniques produce, which the verdict is decided from, so an empty evidence set leaves it unknown",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-test-surface-state-correctness",
            "title": "state-correctness"
          },
          {
            "blocks": [
              {
                "items": [
                  "Dimension: [structure](/records/reasoning/dimension-structure)",
                  "Lens: [structural](/records/reasoning/lens-structure)",
                  "Invariant: [valid-interfaces-and-contracts](/records/reasoning/invariant-valid-interfaces-and-contracts)",
                  "Predicate: [schema](/records/vocabulary/predicate-type-schema)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "A contract is an arrangement of fields and types, so the surface compares the shape of a payload with the shape the contract declares.",
                    "term": "Fit"
                  },
                  {
                    "description": "invalid input/output shape, schema mismatch, contract violation",
                    "term": "Failure modes"
                  },
                  {
                    "description": "[runtime-validation](/records/reasoning/technique-runtime-validation), [contract-testing](/records/reasoning/technique-contract-testing)",
                    "term": "Techniques"
                  },
                  {
                    "description": "[ver-ground-truth](/records/reasoning/node-ver-ground-truth)",
                    "term": "Predicate grounds"
                  },
                  {
                    "description": "[test-result](/records/vocabulary/evidence-source-test-result) · required",
                    "term": "Evidence"
                  },
                  {
                    "description": "[ver-evidence](/records/reasoning/node-ver-evidence)",
                    "term": "Evidence grounds"
                  },
                  {
                    "description": "[pass](/records/vocabulary/verdict-pass), [fail](/records/vocabulary/verdict-fail), [unknown](/records/vocabulary/verdict-unknown)",
                    "term": "Verdicts"
                  }
                ],
                "kind": "glossary"
              },
              {
                "code": "payload models declaredSchema",
                "kind": "code",
                "language": "text",
                "title": "Predicate"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the techniques each surface lists, whose results the surface's predicate and evidence decide, the covered-surfaces check, which validates every surface a module declares covered",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every module that declares the surface covered, and the code under that module",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the module's code, its declaration or the surface changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The covered-surfaces check fails a module that declares an unknown surface; a surface whose evidence is empty stays unknown, never pass",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime techniques among the surface's list, which locate failures without certifying their absence",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a surface with no techniques, an empty verdict domain, a blank predicate and a colliding cell, and the bundled surfaces validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The evidence the surface's techniques produce, which the verdict is decided from, so an empty evidence set leaves it unknown",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-test-surface-interface-correctness",
            "title": "interface-correctness"
          },
          {
            "blocks": [
              {
                "items": [
                  "Dimension: [relation](/records/reasoning/dimension-relation)",
                  "Lens: [relational](/records/reasoning/lens-relation)",
                  "Invariant: [correct-interactions](/records/reasoning/invariant-correct-interactions)",
                  "Predicate: [equivalence](/records/vocabulary/predicate-type-equivalence)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "An interaction is the connection between two components, so the surface checks each request against the response its counterpart owes.",
                    "term": "Fit"
                  },
                  {
                    "description": "wrong API response, incorrect UI behavior, invalid component communication",
                    "term": "Failure modes"
                  },
                  {
                    "description": "[end-to-end-testing](/records/reasoning/technique-end-to-end-testing), [contract-testing](/records/reasoning/technique-contract-testing), [integration-testing](/records/reasoning/technique-integration-testing)",
                    "term": "Techniques"
                  },
                  {
                    "description": "[ver-ground-truth](/records/reasoning/node-ver-ground-truth)",
                    "term": "Predicate grounds"
                  },
                  {
                    "description": "[test-result](/records/vocabulary/evidence-source-test-result) · required",
                    "term": "Evidence"
                  },
                  {
                    "description": "[ver-evidence](/records/reasoning/node-ver-evidence)",
                    "term": "Evidence grounds"
                  },
                  {
                    "description": "[pass](/records/vocabulary/verdict-pass), [fail](/records/vocabulary/verdict-fail), [unknown](/records/vocabulary/verdict-unknown)",
                    "term": "Verdicts"
                  }
                ],
                "kind": "glossary"
              },
              {
                "code": "response = contract(request)",
                "kind": "code",
                "language": "text",
                "title": "Predicate"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the techniques each surface lists, whose results the surface's predicate and evidence decide, the covered-surfaces check, which validates every surface a module declares covered",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every module that declares the surface covered, and the code under that module",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the module's code, its declaration or the surface changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The covered-surfaces check fails a module that declares an unknown surface; a surface whose evidence is empty stays unknown, never pass",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime techniques among the surface's list, which locate failures without certifying their absence",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a surface with no techniques, an empty verdict domain, a blank predicate and a colliding cell, and the bundled surfaces validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The evidence the surface's techniques produce, which the verdict is decided from, so an empty evidence set leaves it unknown",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-test-surface-interaction-correctness",
            "title": "interaction-correctness"
          },
          {
            "blocks": [
              {
                "items": [
                  "Dimension: [time](/records/reasoning/dimension-time)",
                  "Lens: [temporal](/records/reasoning/lens-time)",
                  "Invariant: [acceptable-execution-time](/records/reasoning/invariant-acceptable-execution-time)",
                  "Predicate: [bound](/records/vocabulary/predicate-type-bound)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Execution time is a duration measured across a run, so the surface compares elapsed time with the deadline.",
                    "term": "Fit"
                  },
                  {
                    "description": "timeout, deadline miss, stale data, starvation",
                    "term": "Failure modes"
                  },
                  {
                    "description": "[load-testing](/records/reasoning/technique-load-testing), [monitoring](/records/reasoning/technique-monitoring), [tracing](/records/reasoning/technique-tracing)",
                    "term": "Techniques"
                  },
                  {
                    "description": "[ver-ground-truth](/records/reasoning/node-ver-ground-truth)",
                    "term": "Predicate grounds"
                  },
                  {
                    "description": "[measurement](/records/vocabulary/evidence-source-measurement) · required",
                    "term": "Evidence"
                  },
                  {
                    "description": "[ver-evidence](/records/reasoning/node-ver-evidence)",
                    "term": "Evidence grounds"
                  },
                  {
                    "description": "[pass](/records/vocabulary/verdict-pass), [fail](/records/vocabulary/verdict-fail), [unknown](/records/vocabulary/verdict-unknown)",
                    "term": "Verdicts"
                  }
                ],
                "kind": "glossary"
              },
              {
                "code": "elapsed <= deadline",
                "kind": "code",
                "language": "text",
                "title": "Predicate"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the techniques each surface lists, whose results the surface's predicate and evidence decide, the covered-surfaces check, which validates every surface a module declares covered",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every module that declares the surface covered, and the code under that module",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the module's code, its declaration or the surface changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The covered-surfaces check fails a module that declares an unknown surface; a surface whose evidence is empty stays unknown, never pass",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime techniques among the surface's list, which locate failures without certifying their absence",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a surface with no techniques, an empty verdict domain, a blank predicate and a colliding cell, and the bundled surfaces validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The evidence the surface's techniques produce, which the verdict is decided from, so an empty evidence set leaves it unknown",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-test-surface-temporal-correctness",
            "title": "temporal-correctness"
          },
          {
            "blocks": [
              {
                "items": [
                  "Dimension: [behavior](/records/reasoning/dimension-behavior)",
                  "Lens: [temporal](/records/reasoning/lens-time)",
                  "Invariant: [safe-concurrent-behavior](/records/reasoning/invariant-safe-concurrent-behavior)",
                  "Predicate: [invariant](/records/vocabulary/predicate-type-invariant)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Concurrent code misbehaves only in particular interleavings, so the surface examines what the system does across the orderings time allows.",
                    "term": "Fit"
                  },
                  {
                    "description": "race conditions, deadlocks, livelocks, ordering failures",
                    "term": "Failure modes"
                  },
                  {
                    "description": "[stress-testing](/records/reasoning/technique-stress-testing), [deterministic-replay](/records/reasoning/technique-deterministic-replay)",
                    "term": "Techniques"
                  },
                  {
                    "description": "[ver-ground-truth](/records/reasoning/node-ver-ground-truth)",
                    "term": "Predicate grounds"
                  },
                  {
                    "description": "[runtime-observation](/records/vocabulary/evidence-source-runtime-observation) · required",
                    "term": "Evidence"
                  },
                  {
                    "description": "[ver-evidence](/records/reasoning/node-ver-evidence)",
                    "term": "Evidence grounds"
                  },
                  {
                    "description": "[pass](/records/vocabulary/verdict-pass), [fail](/records/vocabulary/verdict-fail), [unknown](/records/vocabulary/verdict-unknown)",
                    "term": "Verdicts"
                  }
                ],
                "kind": "glossary"
              },
              {
                "code": "for-all interleavings: linearizable(history)",
                "kind": "code",
                "language": "text",
                "title": "Predicate"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the techniques each surface lists, whose results the surface's predicate and evidence decide, the covered-surfaces check, which validates every surface a module declares covered",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every module that declares the surface covered, and the code under that module",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the module's code, its declaration or the surface changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The covered-surfaces check fails a module that declares an unknown surface; a surface whose evidence is empty stays unknown, never pass",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime techniques among the surface's list, which locate failures without certifying their absence",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a surface with no techniques, an empty verdict domain, a blank predicate and a colliding cell, and the bundled surfaces validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The evidence the surface's techniques produce, which the verdict is decided from, so an empty evidence set leaves it unknown",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-test-surface-concurrency-correctness",
            "title": "concurrency-correctness"
          },
          {
            "blocks": [
              {
                "items": [
                  "Dimension: [composition](/records/reasoning/dimension-composition)",
                  "Lens: [evolutionary](/records/reasoning/lens-change)",
                  "Invariant: [controlled-memory-usage](/records/reasoning/invariant-controlled-memory-usage)",
                  "Predicate: [bound](/records/vocabulary/predicate-type-bound)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "A leak shows as the live set growing in content over a long run, so the surface tracks what memory holds as the run develops.",
                    "term": "Fit"
                  },
                  {
                    "description": "memory leaks, excessive allocation, fragmentation, retention bugs",
                    "term": "Failure modes"
                  },
                  {
                    "description": "[heap-analysis](/records/reasoning/technique-heap-analysis), [profiling](/records/reasoning/technique-profiling)",
                    "term": "Techniques"
                  },
                  {
                    "description": "[ver-ground-truth](/records/reasoning/node-ver-ground-truth)",
                    "term": "Predicate grounds"
                  },
                  {
                    "description": "[measurement](/records/vocabulary/evidence-source-measurement) · required",
                    "term": "Evidence"
                  },
                  {
                    "description": "[ver-evidence](/records/reasoning/node-ver-evidence)",
                    "term": "Evidence grounds"
                  },
                  {
                    "description": "[pass](/records/vocabulary/verdict-pass), [fail](/records/vocabulary/verdict-fail), [unknown](/records/vocabulary/verdict-unknown)",
                    "term": "Verdicts"
                  }
                ],
                "kind": "glossary"
              },
              {
                "code": "liveSet bounded as t grows and retained delta approaches 0",
                "kind": "code",
                "language": "text",
                "title": "Predicate"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the techniques each surface lists, whose results the surface's predicate and evidence decide, the covered-surfaces check, which validates every surface a module declares covered",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every module that declares the surface covered, and the code under that module",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the module's code, its declaration or the surface changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The covered-surfaces check fails a module that declares an unknown surface; a surface whose evidence is empty stays unknown, never pass",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime techniques among the surface's list, which locate failures without certifying their absence",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a surface with no techniques, an empty verdict domain, a blank predicate and a colliding cell, and the bundled surfaces validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The evidence the surface's techniques produce, which the verdict is decided from, so an empty evidence set leaves it unknown",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-test-surface-memory-correctness",
            "title": "memory-correctness"
          },
          {
            "blocks": [
              {
                "items": [
                  "Dimension: [composition](/records/reasoning/dimension-composition)",
                  "Lens: [behavioral](/records/reasoning/lens-behavior)",
                  "Invariant: [acceptable-resource-consumption](/records/reasoning/invariant-acceptable-resource-consumption)",
                  "Predicate: [absence](/records/vocabulary/predicate-type-absence)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "A handle leak is a resource the system acquires and never gives back, so the surface pairs each acquisition with its release.",
                    "term": "Fit"
                  },
                  {
                    "description": "file/socket/connection/handle leaks",
                    "term": "Failure modes"
                  },
                  {
                    "description": "[monitoring](/records/reasoning/technique-monitoring), [assertion-checking](/records/reasoning/technique-assertion-checking)",
                    "term": "Techniques"
                  },
                  {
                    "description": "[ver-ground-truth](/records/reasoning/node-ver-ground-truth)",
                    "term": "Predicate grounds"
                  },
                  {
                    "description": "[runtime-observation](/records/vocabulary/evidence-source-runtime-observation) · required",
                    "term": "Evidence"
                  },
                  {
                    "description": "[ver-evidence](/records/reasoning/node-ver-evidence)",
                    "term": "Evidence grounds"
                  },
                  {
                    "description": "[pass](/records/vocabulary/verdict-pass), [fail](/records/vocabulary/verdict-fail), [unknown](/records/vocabulary/verdict-unknown)",
                    "term": "Verdicts"
                  }
                ],
                "kind": "glossary"
              },
              {
                "code": "acquired = released (no leaked handles)",
                "kind": "code",
                "language": "text",
                "title": "Predicate"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the techniques each surface lists, whose results the surface's predicate and evidence decide, the covered-surfaces check, which validates every surface a module declares covered",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every module that declares the surface covered, and the code under that module",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the module's code, its declaration or the surface changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The covered-surfaces check fails a module that declares an unknown surface; a surface whose evidence is empty stays unknown, never pass",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime techniques among the surface's list, which locate failures without certifying their absence",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a surface with no techniques, an empty verdict domain, a blank predicate and a colliding cell, and the bundled surfaces validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The evidence the surface's techniques produce, which the verdict is decided from, so an empty evidence set leaves it unknown",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-test-surface-resource-correctness",
            "title": "resource-correctness"
          },
          {
            "blocks": [
              {
                "items": [
                  "Dimension: [scale](/records/reasoning/dimension-scale)",
                  "Lens: [statistical](/records/reasoning/lens-statistical)",
                  "Invariant: [acceptable-execution-time](/records/reasoning/invariant-acceptable-execution-time)",
                  "Predicate: [bound](/records/vocabulary/predicate-type-bound)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Performance depends on load, and one request says little about it, so the surface reads latency and throughput as distributions over many requests.",
                    "term": "Fit"
                  },
                  {
                    "description": "slow algorithms, excessive CPU, high latency, throughput degradation",
                    "term": "Failure modes"
                  },
                  {
                    "description": "[profiling](/records/reasoning/technique-profiling), [load-testing](/records/reasoning/technique-load-testing)",
                    "term": "Techniques"
                  },
                  {
                    "description": "[ver-ground-truth](/records/reasoning/node-ver-ground-truth)",
                    "term": "Predicate grounds"
                  },
                  {
                    "description": "[measurement](/records/vocabulary/evidence-source-measurement) · required",
                    "term": "Evidence"
                  },
                  {
                    "description": "[ver-evidence](/records/reasoning/node-ver-evidence)",
                    "term": "Evidence grounds"
                  },
                  {
                    "description": "[pass](/records/vocabulary/verdict-pass), [fail](/records/vocabulary/verdict-fail), [unknown](/records/vocabulary/verdict-unknown)",
                    "term": "Verdicts"
                  }
                ],
                "kind": "glossary"
              },
              {
                "code": "latency_p99 <= budget and throughput >= floor",
                "kind": "code",
                "language": "text",
                "title": "Predicate"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the techniques each surface lists, whose results the surface's predicate and evidence decide, the covered-surfaces check, which validates every surface a module declares covered",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every module that declares the surface covered, and the code under that module",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the module's code, its declaration or the surface changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The covered-surfaces check fails a module that declares an unknown surface; a surface whose evidence is empty stays unknown, never pass",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime techniques among the surface's list, which locate failures without certifying their absence",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a surface with no techniques, an empty verdict domain, a blank predicate and a colliding cell, and the bundled surfaces validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The evidence the surface's techniques produce, which the verdict is decided from, so an empty evidence set leaves it unknown",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-test-surface-performance-correctness",
            "title": "performance-correctness"
          },
          {
            "blocks": [
              {
                "items": [
                  "Dimension: [probability](/records/reasoning/dimension-probability)",
                  "Lens: [anomaly](/records/reasoning/lens-anomaly)",
                  "Invariant: [reliability-under-faults](/records/reasoning/invariant-reliability-under-faults)",
                  "Predicate: [absence](/records/vocabulary/predicate-type-absence)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "A crash is a rare departure from normal running, so the surface looks for the inputs and faults that make it likely.",
                    "term": "Fit"
                  },
                  {
                    "description": "crashes, unhandled exceptions, process termination",
                    "term": "Failure modes"
                  },
                  {
                    "description": "[chaos-testing](/records/reasoning/technique-chaos-testing), [fault-injection](/records/reasoning/technique-fault-injection), [monitoring](/records/reasoning/technique-monitoring)",
                    "term": "Techniques"
                  },
                  {
                    "description": "[ver-ground-truth](/records/reasoning/node-ver-ground-truth)",
                    "term": "Predicate grounds"
                  },
                  {
                    "description": "[runtime-observation](/records/vocabulary/evidence-source-runtime-observation) · required",
                    "term": "Evidence"
                  },
                  {
                    "description": "[ver-evidence](/records/reasoning/node-ver-evidence)",
                    "term": "Evidence grounds"
                  },
                  {
                    "description": "[pass](/records/vocabulary/verdict-pass), [fail](/records/vocabulary/verdict-fail), [unknown](/records/vocabulary/verdict-unknown)",
                    "term": "Verdicts"
                  }
                ],
                "kind": "glossary"
              },
              {
                "code": "no input leads to an unhandled fault",
                "kind": "code",
                "language": "text",
                "title": "Predicate"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the techniques each surface lists, whose results the surface's predicate and evidence decide, the covered-surfaces check, which validates every surface a module declares covered",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every module that declares the surface covered, and the code under that module",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the module's code, its declaration or the surface changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The covered-surfaces check fails a module that declares an unknown surface; a surface whose evidence is empty stays unknown, never pass",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime techniques among the surface's list, which locate failures without certifying their absence",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a surface with no techniques, an empty verdict domain, a blank predicate and a colliding cell, and the bundled surfaces validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The evidence the surface's techniques produce, which the verdict is decided from, so an empty evidence set leaves it unknown",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-test-surface-reliability-correctness",
            "title": "reliability-correctness"
          },
          {
            "blocks": [
              {
                "items": [
                  "Dimension: [probability](/records/reasoning/dimension-probability)",
                  "Lens: [temporal](/records/reasoning/lens-time)",
                  "Invariant: [availability-under-stress](/records/reasoning/invariant-availability-under-stress)",
                  "Predicate: [bound](/records/vocabulary/predicate-type-bound)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Availability is the share of time the service answers, so the surface measures uptime over a period under a declared fault set.",
                    "term": "Fit"
                  },
                  {
                    "description": "service outage, cascading failure, degraded service",
                    "term": "Failure modes"
                  },
                  {
                    "description": "[chaos-testing](/records/reasoning/technique-chaos-testing), [fault-injection](/records/reasoning/technique-fault-injection)",
                    "term": "Techniques"
                  },
                  {
                    "description": "[ver-ground-truth](/records/reasoning/node-ver-ground-truth)",
                    "term": "Predicate grounds"
                  },
                  {
                    "description": "[runtime-observation](/records/vocabulary/evidence-source-runtime-observation) · required",
                    "term": "Evidence"
                  },
                  {
                    "description": "[ver-evidence](/records/reasoning/node-ver-evidence)",
                    "term": "Evidence grounds"
                  },
                  {
                    "description": "[pass](/records/vocabulary/verdict-pass), [fail](/records/vocabulary/verdict-fail), [unknown](/records/vocabulary/verdict-unknown)",
                    "term": "Verdicts"
                  }
                ],
                "kind": "glossary"
              },
              {
                "code": "uptime >= SLO under the declared fault set",
                "kind": "code",
                "language": "text",
                "title": "Predicate"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the techniques each surface lists, whose results the surface's predicate and evidence decide, the covered-surfaces check, which validates every surface a module declares covered",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every module that declares the surface covered, and the code under that module",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the module's code, its declaration or the surface changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The covered-surfaces check fails a module that declares an unknown surface; a surface whose evidence is empty stays unknown, never pass",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime techniques among the surface's list, which locate failures without certifying their absence",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a surface with no techniques, an empty verdict domain, a blank predicate and a colliding cell, and the bundled surfaces validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The evidence the surface's techniques produce, which the verdict is decided from, so an empty evidence set leaves it unknown",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-test-surface-availability-correctness",
            "title": "availability-correctness"
          },
          {
            "blocks": [
              {
                "items": [
                  "Dimension: [relation](/records/reasoning/dimension-relation)",
                  "Lens: [statistical](/records/reasoning/lens-statistical)",
                  "Invariant: [consistency-across-components](/records/reasoning/invariant-consistency-across-components)",
                  "Predicate: [invariant](/records/vocabulary/predicate-type-invariant)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Replicas agree or drift as a population, so the surface compares the state of every copy with the others.",
                    "term": "Fit"
                  },
                  {
                    "description": "stale cache, divergent replicas, invalid synchronization",
                    "term": "Failure modes"
                  },
                  {
                    "description": "[differential-testing](/records/reasoning/technique-differential-testing), [assertion-checking](/records/reasoning/technique-assertion-checking)",
                    "term": "Techniques"
                  },
                  {
                    "description": "[ver-ground-truth](/records/reasoning/node-ver-ground-truth)",
                    "term": "Predicate grounds"
                  },
                  {
                    "description": "[test-result](/records/vocabulary/evidence-source-test-result) · required",
                    "term": "Evidence"
                  },
                  {
                    "description": "[ver-evidence](/records/reasoning/node-ver-evidence)",
                    "term": "Evidence grounds"
                  },
                  {
                    "description": "[pass](/records/vocabulary/verdict-pass), [fail](/records/vocabulary/verdict-fail), [unknown](/records/vocabulary/verdict-unknown)",
                    "term": "Verdicts"
                  }
                ],
                "kind": "glossary"
              },
              {
                "code": "for-all replicas: converge(state)",
                "kind": "code",
                "language": "text",
                "title": "Predicate"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the techniques each surface lists, whose results the surface's predicate and evidence decide, the covered-surfaces check, which validates every surface a module declares covered",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every module that declares the surface covered, and the code under that module",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the module's code, its declaration or the surface changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The covered-surfaces check fails a module that declares an unknown surface; a surface whose evidence is empty stays unknown, never pass",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime techniques among the surface's list, which locate failures without certifying their absence",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a surface with no techniques, an empty verdict domain, a blank predicate and a colliding cell, and the bundled surfaces validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The evidence the surface's techniques produce, which the verdict is decided from, so an empty evidence set leaves it unknown",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-test-surface-consistency-correctness",
            "title": "consistency-correctness"
          },
          {
            "blocks": [
              {
                "items": [
                  "Dimension: [identity](/records/reasoning/dimension-identity)",
                  "Lens: [structural](/records/reasoning/lens-structure)",
                  "Invariant: [correct-outputs](/records/reasoning/invariant-correct-outputs)",
                  "Predicate: [invariant](/records/vocabulary/predicate-type-invariant)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Persisted data is correct when each record is still the same record in the same shape, so the surface checks identity and layout across writes and migrations.",
                    "term": "Fit"
                  },
                  {
                    "description": "corrupted persistence, invalid migrations, duplicate records",
                    "term": "Failure modes"
                  },
                  {
                    "description": "[assertion-checking](/records/reasoning/technique-assertion-checking), [integration-testing](/records/reasoning/technique-integration-testing)",
                    "term": "Techniques"
                  },
                  {
                    "description": "[ver-ground-truth](/records/reasoning/node-ver-ground-truth)",
                    "term": "Predicate grounds"
                  },
                  {
                    "description": "[test-result](/records/vocabulary/evidence-source-test-result) · required",
                    "term": "Evidence"
                  },
                  {
                    "description": "[ver-evidence](/records/reasoning/node-ver-evidence)",
                    "term": "Evidence grounds"
                  },
                  {
                    "description": "[pass](/records/vocabulary/verdict-pass), [fail](/records/vocabulary/verdict-fail), [unknown](/records/vocabulary/verdict-unknown)",
                    "term": "Verdicts"
                  }
                ],
                "kind": "glossary"
              },
              {
                "code": "persisted = written and migrate then inverse = identity",
                "kind": "code",
                "language": "text",
                "title": "Predicate"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the techniques each surface lists, whose results the surface's predicate and evidence decide, the covered-surfaces check, which validates every surface a module declares covered",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every module that declares the surface covered, and the code under that module",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the module's code, its declaration or the surface changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The covered-surfaces check fails a module that declares an unknown surface; a surface whose evidence is empty stays unknown, never pass",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime techniques among the surface's list, which locate failures without certifying their absence",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a surface with no techniques, an empty verdict domain, a blank predicate and a colliding cell, and the bundled surfaces validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The evidence the surface's techniques produce, which the verdict is decided from, so an empty evidence set leaves it unknown",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-test-surface-data-correctness",
            "title": "data-correctness"
          },
          {
            "blocks": [
              {
                "items": [
                  "Dimension: [scale](/records/reasoning/dimension-scale)",
                  "Lens: [anomaly](/records/reasoning/lens-anomaly)",
                  "Invariant: [numerical-validity](/records/reasoning/invariant-numerical-validity)",
                  "Predicate: [invariant](/records/vocabulary/predicate-type-invariant)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Numbers fail at the edges of their range, so the surface looks for the magnitudes where a result overflows, loses precision or turns into NaN.",
                    "term": "Fit"
                  },
                  {
                    "description": "overflow, precision loss, NaN propagation",
                    "term": "Failure modes"
                  },
                  {
                    "description": "[property-based-testing](/records/reasoning/technique-property-based-testing), [static-analysis](/records/reasoning/technique-static-analysis)",
                    "term": "Techniques"
                  },
                  {
                    "description": "[ver-ground-truth](/records/reasoning/node-ver-ground-truth)",
                    "term": "Predicate grounds"
                  },
                  {
                    "description": "[analysis-report](/records/vocabulary/evidence-source-analysis-report) · required",
                    "term": "Evidence"
                  },
                  {
                    "description": "[ver-evidence](/records/reasoning/node-ver-evidence)",
                    "term": "Evidence grounds"
                  },
                  {
                    "description": "[pass](/records/vocabulary/verdict-pass), [fail](/records/vocabulary/verdict-fail), [unknown](/records/vocabulary/verdict-unknown)",
                    "term": "Verdicts"
                  }
                ],
                "kind": "glossary"
              },
              {
                "code": "result is finite and not overflow and not NaN",
                "kind": "code",
                "language": "text",
                "title": "Predicate"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the techniques each surface lists, whose results the surface's predicate and evidence decide, the covered-surfaces check, which validates every surface a module declares covered",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every module that declares the surface covered, and the code under that module",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the module's code, its declaration or the surface changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The covered-surfaces check fails a module that declares an unknown surface; a surface whose evidence is empty stays unknown, never pass",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime techniques among the surface's list, which locate failures without certifying their absence",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a surface with no techniques, an empty verdict domain, a blank predicate and a colliding cell, and the bundled surfaces validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The evidence the surface's techniques produce, which the verdict is decided from, so an empty evidence set leaves it unknown",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-test-surface-numerical-correctness",
            "title": "numerical-correctness"
          },
          {
            "blocks": [
              {
                "items": [
                  "Dimension: [cause](/records/reasoning/dimension-cause)",
                  "Lens: [causal](/records/reasoning/lens-cause)",
                  "Invariant: [security-boundaries](/records/reasoning/invariant-security-boundaries)",
                  "Predicate: [absence](/records/vocabulary/predicate-type-absence)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "An exploit is a chain from an input to an effect the boundary should prevent, so the surface traces what each input can cause.",
                    "term": "Fit"
                  },
                  {
                    "description": "injection, privilege escalation, unsafe deserialization",
                    "term": "Failure modes"
                  },
                  {
                    "description": "[static-analysis](/records/reasoning/technique-static-analysis), [fuzz-testing](/records/reasoning/technique-fuzz-testing)",
                    "term": "Techniques"
                  },
                  {
                    "description": "[ver-ground-truth](/records/reasoning/node-ver-ground-truth)",
                    "term": "Predicate grounds"
                  },
                  {
                    "description": "[analysis-report](/records/vocabulary/evidence-source-analysis-report) · required",
                    "term": "Evidence"
                  },
                  {
                    "description": "[ver-evidence](/records/reasoning/node-ver-evidence)",
                    "term": "Evidence grounds"
                  },
                  {
                    "description": "[pass](/records/vocabulary/verdict-pass), [fail](/records/vocabulary/verdict-fail), [unknown](/records/vocabulary/verdict-unknown)",
                    "term": "Verdicts"
                  }
                ],
                "kind": "glossary"
              },
              {
                "code": "no input yields privilege escalation or injection",
                "kind": "code",
                "language": "text",
                "title": "Predicate"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the techniques each surface lists, whose results the surface's predicate and evidence decide, the covered-surfaces check, which validates every surface a module declares covered",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every module that declares the surface covered, and the code under that module",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the module's code, its declaration or the surface changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The covered-surfaces check fails a module that declares an unknown surface; a surface whose evidence is empty stays unknown, never pass",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime techniques among the surface's list, which locate failures without certifying their absence",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a surface with no techniques, an empty verdict domain, a blank predicate and a colliding cell, and the bundled surfaces validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The evidence the surface's techniques produce, which the verdict is decided from, so an empty evidence set leaves it unknown",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-test-surface-security-correctness",
            "title": "security-correctness"
          },
          {
            "blocks": [
              {
                "items": [
                  "Dimension: [novelty](/records/reasoning/dimension-novelty)",
                  "Lens: [anomaly](/records/reasoning/lens-anomaly)",
                  "Invariant: [deterministic-behavior-where-required](/records/reasoning/invariant-deterministic-behavior-where-required)",
                  "Predicate: [equivalence](/records/vocabulary/predicate-type-equivalence)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Nondeterminism appears as an output that differs from the one expected for the same input, so the surface repeats runs and looks for the deviation.",
                    "term": "Fit"
                  },
                  {
                    "description": "the same input producing different outputs",
                    "term": "Failure modes"
                  },
                  {
                    "description": "[property-based-testing](/records/reasoning/technique-property-based-testing), [deterministic-replay](/records/reasoning/technique-deterministic-replay)",
                    "term": "Techniques"
                  },
                  {
                    "description": "[ver-ground-truth](/records/reasoning/node-ver-ground-truth)",
                    "term": "Predicate grounds"
                  },
                  {
                    "description": "[test-result](/records/vocabulary/evidence-source-test-result) · required",
                    "term": "Evidence"
                  },
                  {
                    "description": "[ver-evidence](/records/reasoning/node-ver-evidence)",
                    "term": "Evidence grounds"
                  },
                  {
                    "description": "[pass](/records/vocabulary/verdict-pass), [fail](/records/vocabulary/verdict-fail), [unknown](/records/vocabulary/verdict-unknown)",
                    "term": "Verdicts"
                  }
                ],
                "kind": "glossary"
              },
              {
                "code": "f(x) = f(x) across runs",
                "kind": "code",
                "language": "text",
                "title": "Predicate"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the techniques each surface lists, whose results the surface's predicate and evidence decide, the covered-surfaces check, which validates every surface a module declares covered",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every module that declares the surface covered, and the code under that module",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the module's code, its declaration or the surface changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The covered-surfaces check fails a module that declares an unknown surface; a surface whose evidence is empty stays unknown, never pass",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime techniques among the surface's list, which locate failures without certifying their absence",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a surface with no techniques, an empty verdict domain, a blank predicate and a colliding cell, and the bundled surfaces validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The evidence the surface's techniques produce, which the verdict is decided from, so an empty evidence set leaves it unknown",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-test-surface-determinism-correctness",
            "title": "determinism-correctness"
          },
          {
            "blocks": [
              {
                "items": [
                  "Dimension: [relation](/records/reasoning/dimension-relation)",
                  "Lens: [sequential](/records/reasoning/lens-sequential)",
                  "Invariant: [protocol-compliance](/records/reasoning/invariant-protocol-compliance)",
                  "Predicate: [temporal-order](/records/vocabulary/predicate-type-temporal-order)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "A protocol is a relation between parties that holds only in a given order of messages, so the surface checks the sequence against the protocol's grammar.",
                    "term": "Fit"
                  },
                  {
                    "description": "invalid message ordering, malformed communication sequence",
                    "term": "Failure modes"
                  },
                  {
                    "description": "[contract-testing](/records/reasoning/technique-contract-testing), [model-checking](/records/reasoning/technique-model-checking)",
                    "term": "Techniques"
                  },
                  {
                    "description": "[ver-ground-truth](/records/reasoning/node-ver-ground-truth)",
                    "term": "Predicate grounds"
                  },
                  {
                    "description": "[test-result](/records/vocabulary/evidence-source-test-result) · required",
                    "term": "Evidence"
                  },
                  {
                    "description": "[ver-evidence](/records/reasoning/node-ver-evidence)",
                    "term": "Evidence grounds"
                  },
                  {
                    "description": "[pass](/records/vocabulary/verdict-pass), [fail](/records/vocabulary/verdict-fail), [unknown](/records/vocabulary/verdict-unknown)",
                    "term": "Verdicts"
                  }
                ],
                "kind": "glossary"
              },
              {
                "code": "messageSeq in protocolGrammar",
                "kind": "code",
                "language": "text",
                "title": "Predicate"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the techniques each surface lists, whose results the surface's predicate and evidence decide, the covered-surfaces check, which validates every surface a module declares covered",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every module that declares the surface covered, and the code under that module",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the module's code, its declaration or the surface changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The covered-surfaces check fails a module that declares an unknown surface; a surface whose evidence is empty stays unknown, never pass",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime techniques among the surface's list, which locate failures without certifying their absence",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a surface with no techniques, an empty verdict domain, a blank predicate and a colliding cell, and the bundled surfaces validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The evidence the surface's techniques produce, which the verdict is decided from, so an empty evidence set leaves it unknown",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-test-surface-protocol-correctness",
            "title": "protocol-correctness"
          },
          {
            "blocks": [
              {
                "items": [
                  "Dimension: [state](/records/reasoning/dimension-state)",
                  "Lens: [structural](/records/reasoning/lens-structure)",
                  "Invariant: [configuration-validity](/records/reasoning/invariant-configuration-validity)",
                  "Predicate: [schema](/records/vocabulary/predicate-type-schema)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Configuration is the condition a deployment starts in, and it is valid when its keys and values take the declared shape, so the surface checks it against its schema.",
                    "term": "Fit"
                  },
                  {
                    "description": "invalid environment variables, feature flag errors, deployment mismatch",
                    "term": "Failure modes"
                  },
                  {
                    "description": "[runtime-validation](/records/reasoning/technique-runtime-validation), [static-analysis](/records/reasoning/technique-static-analysis)",
                    "term": "Techniques"
                  },
                  {
                    "description": "[ver-ground-truth](/records/reasoning/node-ver-ground-truth)",
                    "term": "Predicate grounds"
                  },
                  {
                    "description": "[analysis-report](/records/vocabulary/evidence-source-analysis-report) · required",
                    "term": "Evidence"
                  },
                  {
                    "description": "[ver-evidence](/records/reasoning/node-ver-evidence)",
                    "term": "Evidence grounds"
                  },
                  {
                    "description": "[pass](/records/vocabulary/verdict-pass), [fail](/records/vocabulary/verdict-fail), [unknown](/records/vocabulary/verdict-unknown)",
                    "term": "Verdicts"
                  }
                ],
                "kind": "glossary"
              },
              {
                "code": "config models configSchema",
                "kind": "code",
                "language": "text",
                "title": "Predicate"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the techniques each surface lists, whose results the surface's predicate and evidence decide, the covered-surfaces check, which validates every surface a module declares covered",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every module that declares the surface covered, and the code under that module",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the module's code, its declaration or the surface changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The covered-surfaces check fails a module that declares an unknown surface; a surface whose evidence is empty stays unknown, never pass",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime techniques among the surface's list, which locate failures without certifying their absence",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a surface with no techniques, an empty verdict domain, a blank predicate and a colliding cell, and the bundled surfaces validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The evidence the surface's techniques produce, which the verdict is decided from, so an empty evidence set leaves it unknown",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-test-surface-configuration-correctness",
            "title": "configuration-correctness"
          },
          {
            "blocks": [
              {
                "items": [
                  "Dimension: [meaning](/records/reasoning/dimension-meaning)",
                  "Lens: [frequency](/records/reasoning/lens-frequency)",
                  "Invariant: [accurate-observability](/records/reasoning/invariant-accurate-observability)",
                  "Predicate: [invariant](/records/vocabulary/predicate-type-invariant)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "A signal is accurate when every event it stands for is emitted each time the event occurs, so the surface compares how often events happen with how often they are reported.",
                    "term": "Fit"
                  },
                  {
                    "description": "missing logs, incorrect metrics, broken traces",
                    "term": "Failure modes"
                  },
                  {
                    "description": "[monitoring](/records/reasoning/technique-monitoring), [tracing](/records/reasoning/technique-tracing)",
                    "term": "Techniques"
                  },
                  {
                    "description": "[ver-ground-truth](/records/reasoning/node-ver-ground-truth)",
                    "term": "Predicate grounds"
                  },
                  {
                    "description": "[runtime-observation](/records/vocabulary/evidence-source-runtime-observation) · required",
                    "term": "Evidence"
                  },
                  {
                    "description": "[ver-evidence](/records/reasoning/node-ver-evidence)",
                    "term": "Evidence grounds"
                  },
                  {
                    "description": "[pass](/records/vocabulary/verdict-pass), [fail](/records/vocabulary/verdict-fail), [unknown](/records/vocabulary/verdict-unknown)",
                    "term": "Verdicts"
                  }
                ],
                "kind": "glossary"
              },
              {
                "code": "for-all event: emitted and measurable",
                "kind": "code",
                "language": "text",
                "title": "Predicate"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the techniques each surface lists, whose results the surface's predicate and evidence decide, the covered-surfaces check, which validates every surface a module declares covered",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every module that declares the surface covered, and the code under that module",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the module's code, its declaration or the surface changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The covered-surfaces check fails a module that declares an unknown surface; a surface whose evidence is empty stays unknown, never pass",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime techniques among the surface's list, which locate failures without certifying their absence",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a surface with no techniques, an empty verdict domain, a blank predicate and a colliding cell, and the bundled surfaces validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The evidence the surface's techniques produce, which the verdict is decided from, so an empty evidence set leaves it unknown",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-test-surface-observability-correctness",
            "title": "observability-correctness"
          }
        ],
        "title": "The test surfaces"
      },
      {
        "icon": "bi-signpost-split",
        "id": "the-techniques",
        "intro": "Each technique a surface is observed by works in one reasoning mode and is listed with the surfaces that use it.",
        "subsections": [
          {
            "blocks": [
              {
                "items": [
                  "Mode: [observation](/records/reasoning/mode-observation)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Reads structure and types for defects before execution",
                    "term": "Principle"
                  },
                  {
                    "description": "[Static Analysis](/records/architecture/static-analysis)",
                    "term": "Refused by rules"
                  },
                  {
                    "description": "Reports nothing when its rule never visits the construct, as with a misspelled visitor key",
                    "term": "Goes silent when"
                  },
                  {
                    "description": "[numerical-correctness](/records/reasoning/test-surface-numerical-correctness), [security-correctness](/records/reasoning/test-surface-security-correctness), [configuration-correctness](/records/reasoning/test-surface-configuration-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every surface that lists the technique, and the code those surfaces cover",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the technique, a surface that lists it or the covered code changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails",
                    "term": "Refusal"
                  },
                  {
                    "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The technique record, which every surface that lists it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-technique-static-analysis",
            "title": "static-analysis"
          },
          {
            "blocks": [
              {
                "items": [
                  "Mode: [comparison](/records/reasoning/mode-comparison)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Compares observed with expected results on an isolated unit",
                    "term": "Principle"
                  },
                  {
                    "description": "Passes when the doubles that isolate the unit no longer behave like the real collaborators",
                    "term": "Goes silent when"
                  },
                  {
                    "description": "[semantic-correctness](/records/reasoning/test-surface-semantic-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every surface that lists the technique, and the code those surfaces cover",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the technique, a surface that lists it or the covered code changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails",
                    "term": "Refusal"
                  },
                  {
                    "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The technique record, which every surface that lists it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-technique-unit-testing",
            "title": "unit-testing"
          },
          {
            "blocks": [
              {
                "items": [
                  "Mode: [comparison](/records/reasoning/mode-comparison)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Compares observed with expected results across cooperating parts",
                    "term": "Principle"
                  },
                  {
                    "description": "Passes on an environment that differs from production in the part that fails",
                    "term": "Goes silent when"
                  },
                  {
                    "description": "[functional-correctness](/records/reasoning/test-surface-functional-correctness), [interaction-correctness](/records/reasoning/test-surface-interaction-correctness), [data-correctness](/records/reasoning/test-surface-data-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every surface that lists the technique, and the code those surfaces cover",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the technique, a surface that lists it or the covered code changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails",
                    "term": "Refusal"
                  },
                  {
                    "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The technique record, which every surface that lists it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-technique-integration-testing",
            "title": "integration-testing"
          },
          {
            "blocks": [
              {
                "items": [
                  "Mode: [comparison](/records/reasoning/mode-comparison)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Compares observed with expected results on the whole system",
                    "term": "Principle"
                  },
                  {
                    "description": "Is retried until it passes, so an intermittent failure is read as noise",
                    "term": "Goes silent when"
                  },
                  {
                    "description": "[interaction-correctness](/records/reasoning/test-surface-interaction-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every surface that lists the technique, and the code those surfaces cover",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the technique, a surface that lists it or the covered code changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails",
                    "term": "Refusal"
                  },
                  {
                    "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The technique record, which every surface that lists it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-technique-end-to-end-testing",
            "title": "end-to-end-testing"
          },
          {
            "blocks": [
              {
                "items": [
                  "Mode: [classification](/records/reasoning/mode-classification)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Asserts that an invariant holds across a generated input space",
                    "term": "Principle"
                  },
                  {
                    "description": "[Property-Based Testing](/records/architecture/property-based-testing)",
                    "term": "Refused by rules"
                  },
                  {
                    "description": "Passes when the generator never produces the inputs that break the property",
                    "term": "Goes silent when"
                  },
                  {
                    "description": "[semantic-correctness](/records/reasoning/test-surface-semantic-correctness), [state-correctness](/records/reasoning/test-surface-state-correctness), [numerical-correctness](/records/reasoning/test-surface-numerical-correctness), [determinism-correctness](/records/reasoning/test-surface-determinism-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every surface that lists the technique, and the code those surfaces cover",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the technique, a surface that lists it or the covered code changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails",
                    "term": "Refusal"
                  },
                  {
                    "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The technique record, which every surface that lists it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-technique-property-based-testing",
            "title": "property-based-testing"
          },
          {
            "blocks": [
              {
                "items": [
                  "Mode: [comparison](/records/reasoning/mode-comparison)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Compares observed results with a reference implementation, the oracle",
                    "term": "Principle"
                  },
                  {
                    "description": "Passes when the reference implementation shares the defect",
                    "term": "Goes silent when"
                  },
                  {
                    "description": "[semantic-correctness](/records/reasoning/test-surface-semantic-correctness), [consistency-correctness](/records/reasoning/test-surface-consistency-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every surface that lists the technique, and the code those surfaces cover",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the technique, a surface that lists it or the covered code changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails",
                    "term": "Refusal"
                  },
                  {
                    "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The technique record, which every surface that lists it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-technique-differential-testing",
            "title": "differential-testing"
          },
          {
            "blocks": [
              {
                "items": [
                  "Mode: [comparison](/records/reasoning/mode-comparison)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Compares an observed interface with an agreed contract",
                    "term": "Principle"
                  },
                  {
                    "description": "Passes against a copy of the contract that drifted from the one the provider serves",
                    "term": "Goes silent when"
                  },
                  {
                    "description": "[interface-correctness](/records/reasoning/test-surface-interface-correctness), [interaction-correctness](/records/reasoning/test-surface-interaction-correctness), [protocol-correctness](/records/reasoning/test-surface-protocol-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every surface that lists the technique, and the code those surfaces cover",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the technique, a surface that lists it or the covered code changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails",
                    "term": "Refusal"
                  },
                  {
                    "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The technique record, which every surface that lists it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-technique-contract-testing",
            "title": "contract-testing"
          },
          {
            "blocks": [
              {
                "items": [
                  "Mode: [observation](/records/reasoning/mode-observation)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Checks boundary data against its declared shape at runtime",
                    "term": "Principle"
                  },
                  {
                    "description": "Never runs on a path that reaches the core without crossing the boundary",
                    "term": "Goes silent when"
                  },
                  {
                    "description": "[interface-correctness](/records/reasoning/test-surface-interface-correctness), [configuration-correctness](/records/reasoning/test-surface-configuration-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every surface that lists the technique, and the code those surfaces cover",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the technique, a surface that lists it or the covered code changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails",
                    "term": "Refusal"
                  },
                  {
                    "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The technique record, which every surface that lists it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-technique-runtime-validation",
            "title": "runtime-validation"
          },
          {
            "blocks": [
              {
                "items": [
                  "Mode: [comparison](/records/reasoning/mode-comparison)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Checks a runtime condition against an assumed invariant",
                    "term": "Principle"
                  },
                  {
                    "description": "Is compiled out or disabled in the build that runs in production",
                    "term": "Goes silent when"
                  },
                  {
                    "description": "[semantic-correctness](/records/reasoning/test-surface-semantic-correctness), [state-correctness](/records/reasoning/test-surface-state-correctness), [resource-correctness](/records/reasoning/test-surface-resource-correctness), [consistency-correctness](/records/reasoning/test-surface-consistency-correctness), [data-correctness](/records/reasoning/test-surface-data-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every surface that lists the technique, and the code those surfaces cover",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the technique, a surface that lists it or the covered code changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails",
                    "term": "Refusal"
                  },
                  {
                    "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The technique record, which every surface that lists it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-technique-assertion-checking",
            "title": "assertion-checking"
          },
          {
            "blocks": [
              {
                "items": [
                  "Mode: [creation](/records/reasoning/mode-creation)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Generates adversarial inputs to provoke unhandled failures",
                    "term": "Principle"
                  },
                  {
                    "description": "Stops before the generated inputs reach the failing region, and the run reports no crash",
                    "term": "Goes silent when"
                  },
                  {
                    "description": "[security-correctness](/records/reasoning/test-surface-security-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every surface that lists the technique, and the code those surfaces cover",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the technique, a surface that lists it or the covered code changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails",
                    "term": "Refusal"
                  },
                  {
                    "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The technique record, which every surface that lists it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-technique-fuzz-testing",
            "title": "fuzz-testing"
          },
          {
            "blocks": [
              {
                "items": [
                  "Mode: [prediction](/records/reasoning/mode-prediction)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Projects behavior under expected demand",
                    "term": "Principle"
                  },
                  {
                    "description": "Runs a workload shaped unlike real demand",
                    "term": "Goes silent when"
                  },
                  {
                    "description": "[temporal-correctness](/records/reasoning/test-surface-temporal-correctness), [performance-correctness](/records/reasoning/test-surface-performance-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every surface that lists the technique, and the code those surfaces cover",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the technique, a surface that lists it or the covered code changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails",
                    "term": "Refusal"
                  },
                  {
                    "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The technique record, which every surface that lists it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-technique-load-testing",
            "title": "load-testing"
          },
          {
            "blocks": [
              {
                "items": [
                  "Mode: [prediction](/records/reasoning/mode-prediction)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Projects behavior past its limits to expose timing and ordering defects",
                    "term": "Principle"
                  },
                  {
                    "description": "Ends at a limit below the one production reaches",
                    "term": "Goes silent when"
                  },
                  {
                    "description": "[concurrency-correctness](/records/reasoning/test-surface-concurrency-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every surface that lists the technique, and the code those surfaces cover",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the technique, a surface that lists it or the covered code changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails",
                    "term": "Refusal"
                  },
                  {
                    "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The technique record, which every surface that lists it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-technique-stress-testing",
            "title": "stress-testing"
          },
          {
            "blocks": [
              {
                "items": [
                  "Mode: [observation](/records/reasoning/mode-observation)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Measures the distribution of execution cost",
                    "term": "Principle"
                  },
                  {
                    "description": "[Profiling](/records/architecture/profiling)",
                    "term": "Refused by rules"
                  },
                  {
                    "description": "Samples too coarsely to see a short, frequent cost",
                    "term": "Goes silent when"
                  },
                  {
                    "description": "[memory-correctness](/records/reasoning/test-surface-memory-correctness), [performance-correctness](/records/reasoning/test-surface-performance-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every surface that lists the technique, and the code those surfaces cover",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the technique, a surface that lists it or the covered code changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails",
                    "term": "Refusal"
                  },
                  {
                    "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The technique record, which every surface that lists it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-technique-profiling",
            "title": "profiling"
          },
          {
            "blocks": [
              {
                "items": [
                  "Mode: [observation](/records/reasoning/mode-observation)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Measures allocation and retention over time",
                    "term": "Principle"
                  },
                  {
                    "description": "Measures a run too short for retention to show",
                    "term": "Goes silent when"
                  },
                  {
                    "description": "[memory-correctness](/records/reasoning/test-surface-memory-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every surface that lists the technique, and the code those surfaces cover",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the technique, a surface that lists it or the covered code changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails",
                    "term": "Refusal"
                  },
                  {
                    "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The technique record, which every surface that lists it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-technique-heap-analysis",
            "title": "heap-analysis"
          },
          {
            "blocks": [
              {
                "items": [
                  "Mode: [description](/records/reasoning/mode-description)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Describes the runtime flow across components",
                    "term": "Principle"
                  },
                  {
                    "description": "Loses spans at an uninstrumented hop, and the trace reads as complete",
                    "term": "Goes silent when"
                  },
                  {
                    "description": "[temporal-correctness](/records/reasoning/test-surface-temporal-correctness), [observability-correctness](/records/reasoning/test-surface-observability-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every surface that lists the technique, and the code those surfaces cover",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the technique, a surface that lists it or the covered code changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails",
                    "term": "Refusal"
                  },
                  {
                    "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The technique record, which every surface that lists it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-technique-tracing",
            "title": "tracing"
          },
          {
            "blocks": [
              {
                "items": [
                  "Mode: [intervention](/records/reasoning/mode-intervention)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Induces a failure and observes the response",
                    "term": "Principle"
                  },
                  {
                    "description": "Injects only the faults the developer anticipated",
                    "term": "Goes silent when"
                  },
                  {
                    "description": "[reliability-correctness](/records/reasoning/test-surface-reliability-correctness), [availability-correctness](/records/reasoning/test-surface-availability-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every surface that lists the technique, and the code those surfaces cover",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the technique, a surface that lists it or the covered code changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails",
                    "term": "Refusal"
                  },
                  {
                    "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The technique record, which every surface that lists it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-technique-fault-injection",
            "title": "fault-injection"
          },
          {
            "blocks": [
              {
                "items": [
                  "Mode: [intervention](/records/reasoning/mode-intervention)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Induces random failures and observes how the system recovers",
                    "term": "Principle"
                  },
                  {
                    "description": "Runs where the dependency that fails in production is absent",
                    "term": "Goes silent when"
                  },
                  {
                    "description": "[reliability-correctness](/records/reasoning/test-surface-reliability-correctness), [availability-correctness](/records/reasoning/test-surface-availability-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every surface that lists the technique, and the code those surfaces cover",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the technique, a surface that lists it or the covered code changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails",
                    "term": "Refusal"
                  },
                  {
                    "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The technique record, which every surface that lists it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-technique-chaos-testing",
            "title": "chaos-testing"
          },
          {
            "blocks": [
              {
                "items": [
                  "Mode: [explanation](/records/reasoning/mode-explanation)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Proves that a property holds across the reachable state space",
                    "term": "Principle"
                  },
                  {
                    "description": "Proves the model while the code drifts away from it",
                    "term": "Goes silent when"
                  },
                  {
                    "description": "[functional-correctness](/records/reasoning/test-surface-functional-correctness), [protocol-correctness](/records/reasoning/test-surface-protocol-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every surface that lists the technique, and the code those surfaces cover",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the technique, a surface that lists it or the covered code changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails",
                    "term": "Refusal"
                  },
                  {
                    "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The technique record, which every surface that lists it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-technique-model-checking",
            "title": "model-checking"
          },
          {
            "blocks": [
              {
                "items": [
                  "Mode: [reflection](/records/reasoning/mode-reflection)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Reproduces a run to isolate a non-deterministic cause",
                    "term": "Principle"
                  },
                  {
                    "description": "Replays a recording that left out the source of the non-determinism",
                    "term": "Goes silent when"
                  },
                  {
                    "description": "[concurrency-correctness](/records/reasoning/test-surface-concurrency-correctness), [determinism-correctness](/records/reasoning/test-surface-determinism-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every surface that lists the technique, and the code those surfaces cover",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the technique, a surface that lists it or the covered code changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails",
                    "term": "Refusal"
                  },
                  {
                    "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The technique record, which every surface that lists it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-technique-deterministic-replay",
            "title": "deterministic-replay"
          },
          {
            "blocks": [
              {
                "items": [
                  "Mode: [observation](/records/reasoning/mode-observation)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Observes live behavior for deviations from normal",
                    "term": "Principle"
                  },
                  {
                    "description": "[Monitoring](/records/architecture/monitoring)",
                    "term": "Refused by rules"
                  },
                  {
                    "description": "Reports no deviation because the signal it watches was never emitted",
                    "term": "Goes silent when"
                  },
                  {
                    "description": "[temporal-correctness](/records/reasoning/test-surface-temporal-correctness), [resource-correctness](/records/reasoning/test-surface-resource-correctness), [reliability-correctness](/records/reasoning/test-surface-reliability-correctness), [observability-correctness](/records/reasoning/test-surface-observability-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every surface that lists the technique, and the code those surfaces cover",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the technique, a surface that lists it or the covered code changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails",
                    "term": "Refusal"
                  },
                  {
                    "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The technique record, which every surface that lists it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-technique-monitoring",
            "title": "monitoring"
          },
          {
            "blocks": [
              {
                "items": [
                  "Mode: [intervention](/records/reasoning/mode-intervention)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Introduces a deliberate defect and checks that the tests or the rule report it",
                    "term": "Principle"
                  },
                  {
                    "description": "Counts a mutant as caught by a test that fails for an unrelated reason",
                    "term": "Goes silent when"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every surface that lists the technique, and the code those surfaces cover",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the technique, a surface that lists it or the covered code changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails",
                    "term": "Refusal"
                  },
                  {
                    "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The technique record, which every surface that lists it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-technique-mutation-testing",
            "title": "mutation-testing"
          },
          {
            "blocks": [
              {
                "items": [
                  "Mode: [comparison](/records/reasoning/mode-comparison)"
                ],
                "kind": "list"
              },
              {
                "entries": [
                  {
                    "description": "Reads back what was written and compares it with what was meant to be written",
                    "term": "Principle"
                  },
                  {
                    "description": "Reads from a cache or a buffer instead of the store the write reached",
                    "term": "Goes silent when"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that list the technique, whose predicates decide what a run of the technique shows",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every surface that lists the technique, and the code those surfaces cover",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the technique, a surface that lists it or the covered code changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails a surface that lists an unknown technique, and a technique that states no way it fails",
                    "term": "Refusal"
                  },
                  {
                    "description": "The technique's own runs, which locate failures; its fails field names the way it goes silent",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that lists an unknown technique, another plants a technique that states no way it fails, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The technique record, which every surface that lists it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-technique-read-after-write-verification",
            "title": "read-after-write-verification"
          }
        ],
        "title": "The techniques"
      },
      {
        "icon": "bi-signpost-split",
        "id": "the-invariants",
        "intro": "Each invariant the test surfaces assert is listed with the surfaces that assert it.",
        "subsections": [
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "Outputs are correct",
                    "term": "Invariant"
                  },
                  {
                    "description": "[semantic-correctness](/records/reasoning/test-surface-semantic-correctness), [data-correctness](/records/reasoning/test-surface-data-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every test surface and document construct that names the invariant",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The invariant record, which every surface and document construct that asserts it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-invariant-correct-outputs",
            "title": "Correct Outputs"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "State evolves correctly",
                    "term": "Invariant"
                  },
                  {
                    "description": "[functional-correctness](/records/reasoning/test-surface-functional-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every test surface and document construct that names the invariant",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The invariant record, which every surface and document construct that asserts it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-invariant-correct-state-evolution",
            "title": "Correct State Evolution"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "State transitions are valid",
                    "term": "Invariant"
                  },
                  {
                    "description": "[state-correctness](/records/reasoning/test-surface-state-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every test surface and document construct that names the invariant",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The invariant record, which every surface and document construct that asserts it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-invariant-valid-state-transitions",
            "title": "Valid State Transitions"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "Interactions between components are correct",
                    "term": "Invariant"
                  },
                  {
                    "description": "[interaction-correctness](/records/reasoning/test-surface-interaction-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every test surface and document construct that names the invariant",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The invariant record, which every surface and document construct that asserts it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-invariant-correct-interactions",
            "title": "Correct Interactions"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "Interfaces and contracts are valid",
                    "term": "Invariant"
                  },
                  {
                    "description": "[interface-correctness](/records/reasoning/test-surface-interface-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every test surface and document construct that names the invariant",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The invariant record, which every surface and document construct that asserts it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-invariant-valid-interfaces-and-contracts",
            "title": "Valid Interfaces and Contracts"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "Execution time is acceptable",
                    "term": "Invariant"
                  },
                  {
                    "description": "[temporal-correctness](/records/reasoning/test-surface-temporal-correctness), [performance-correctness](/records/reasoning/test-surface-performance-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every test surface and document construct that names the invariant",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The invariant record, which every surface and document construct that asserts it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-invariant-acceptable-execution-time",
            "title": "Acceptable Execution Time"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "Resource consumption is acceptable",
                    "term": "Invariant"
                  },
                  {
                    "description": "[resource-correctness](/records/reasoning/test-surface-resource-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every test surface and document construct that names the invariant",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The invariant record, which every surface and document construct that asserts it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-invariant-acceptable-resource-consumption",
            "title": "Acceptable Resource Consumption"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "Concurrent behavior is safe",
                    "term": "Invariant"
                  },
                  {
                    "description": "[concurrency-correctness](/records/reasoning/test-surface-concurrency-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every test surface and document construct that names the invariant",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The invariant record, which every surface and document construct that asserts it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-invariant-safe-concurrent-behavior",
            "title": "Safe Concurrent Behavior"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "Memory usage is controlled",
                    "term": "Invariant"
                  },
                  {
                    "description": "[memory-correctness](/records/reasoning/test-surface-memory-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every test surface and document construct that names the invariant",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The invariant record, which every surface and document construct that asserts it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-invariant-controlled-memory-usage",
            "title": "Controlled Memory Usage"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "The system stays reliable under faults",
                    "term": "Invariant"
                  },
                  {
                    "description": "[reliability-correctness](/records/reasoning/test-surface-reliability-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every test surface and document construct that names the invariant",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The invariant record, which every surface and document construct that asserts it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-invariant-reliability-under-faults",
            "title": "Reliability Under Faults"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "The system stays available under stress",
                    "term": "Invariant"
                  },
                  {
                    "description": "[availability-correctness](/records/reasoning/test-surface-availability-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every test surface and document construct that names the invariant",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The invariant record, which every surface and document construct that asserts it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-invariant-availability-under-stress",
            "title": "Availability Under Stress"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "Components stay consistent with each other",
                    "term": "Invariant"
                  },
                  {
                    "description": "[consistency-correctness](/records/reasoning/test-surface-consistency-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every test surface and document construct that names the invariant",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The invariant record, which every surface and document construct that asserts it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-invariant-consistency-across-components",
            "title": "Consistency Across Components"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "Behavior is deterministic where determinism is required",
                    "term": "Invariant"
                  },
                  {
                    "description": "[determinism-correctness](/records/reasoning/test-surface-determinism-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every test surface and document construct that names the invariant",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The invariant record, which every surface and document construct that asserts it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-invariant-deterministic-behavior-where-required",
            "title": "Required Determinism"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "Numerical results are valid",
                    "term": "Invariant"
                  },
                  {
                    "description": "[numerical-correctness](/records/reasoning/test-surface-numerical-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every test surface and document construct that names the invariant",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The invariant record, which every surface and document construct that asserts it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-invariant-numerical-validity",
            "title": "Numerical Validity"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "Security boundaries hold",
                    "term": "Invariant"
                  },
                  {
                    "description": "[security-correctness](/records/reasoning/test-surface-security-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every test surface and document construct that names the invariant",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The invariant record, which every surface and document construct that asserts it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-invariant-security-boundaries",
            "title": "Security Boundaries"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "Communication complies with its protocol",
                    "term": "Invariant"
                  },
                  {
                    "description": "[protocol-correctness](/records/reasoning/test-surface-protocol-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every test surface and document construct that names the invariant",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The invariant record, which every surface and document construct that asserts it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-invariant-protocol-compliance",
            "title": "Protocol Compliance"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "Configuration is valid",
                    "term": "Invariant"
                  },
                  {
                    "description": "[configuration-correctness](/records/reasoning/test-surface-configuration-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every test surface and document construct that names the invariant",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The invariant record, which every surface and document construct that asserts it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-invariant-configuration-validity",
            "title": "Configuration Validity"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "Logs, metrics and traces report the system accurately",
                    "term": "Invariant"
                  },
                  {
                    "description": "[observability-correctness](/records/reasoning/test-surface-observability-correctness)",
                    "term": "Surfaces"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every test surface and document construct that names the invariant",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The invariant record, which every surface and document construct that asserts it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-invariant-accurate-observability",
            "title": "Accurate Observability"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "Every representation in jurisdiction has a computable check",
                    "term": "Invariant"
                  },
                  {
                    "description": "[meta_field](/records/pag/production-meta-field)",
                    "term": "Grounded by"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every test surface and document construct that names the invariant",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The invariant record, which every surface and document construct that asserts it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-invariant-epi-reachable-check",
            "title": "Reachable Check"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "A check's domain is explicit and reported beside its verdict",
                    "term": "Invariant"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every test surface and document construct that names the invariant",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The invariant record, which every surface and document construct that asserts it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-invariant-epi-declared-domain",
            "title": "Declared Domain"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "A dependency is declared by the referent, never inferred from a name",
                    "term": "Invariant"
                  },
                  {
                    "description": "[dag_declaration](/records/pag/production-dag-declaration), [edge_clause](/records/pag/production-edge-clause)",
                    "term": "Grounded by"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every test surface and document construct that names the invariant",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The invariant record, which every surface and document construct that asserts it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-invariant-epi-declared-dependency",
            "title": "Declared Dependency"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "A verdict is itself a representation and has a reachable check of its own",
                    "term": "Invariant"
                  },
                  {
                    "description": "[report_block](/records/pag/production-report-block)",
                    "term": "Grounded by"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every test surface and document construct that names the invariant",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The invariant record, which every surface and document construct that asserts it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-invariant-epi-verdict-is-representation",
            "title": "Checked Verdict"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "A lowering keeps every distinction a later check needs",
                    "term": "Invariant"
                  },
                  {
                    "description": "[preserves_clause](/records/pag/production-preserves-clause)",
                    "term": "Grounded by"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every test surface and document construct that names the invariant",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The invariant record, which every surface and document construct that asserts it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-invariant-epi-preserved-distinction",
            "title": "Preserved Distinction"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "A check reads a representation derived after the last relevant mutator",
                    "term": "Invariant"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every test surface and document construct that names the invariant",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The invariant record, which every surface and document construct that asserts it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-invariant-epi-fresh-read",
            "title": "Fresh Read"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "One canonical question has one authoritative derivation",
                    "term": "Invariant"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every test surface and document construct that names the invariant",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The invariant record, which every surface and document construct that asserts it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-invariant-epi-one-derivation",
            "title": "One Derivation"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "A chain is as certain as its least certain link, and a link below the floor is removed from the chain",
                    "term": "Invariant"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every test surface and document construct that names the invariant",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The invariant record, which every surface and document construct that asserts it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-invariant-epi-weakest-link",
            "title": "Weakest Link"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "Dynamic observation locates a failure and never certifies absence",
                    "term": "Invariant"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every test surface and document construct that names the invariant",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The invariant record, which every surface and document construct that asserts it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-invariant-epi-observation-locates",
            "title": "Observation Scope"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "A run stops when saturation, completion and verification all hold, or when it is blocked on something outside it",
                    "term": "Invariant"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the test surfaces that assert the invariant, through the techniques each surface lists, the structured-document validator, for each epistemic invariant the grammar's constructs ground",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every test surface and document construct that names the invariant",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the invariant, a surface that asserts it or a construct that grounds it changes",
                    "term": "Freshness"
                  },
                  {
                    "description": "The gate fails on a surface that names an unknown invariant, and the document validator fails a gate that omits a grounded clause",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime techniques among the surfaces that assert the invariant, which locate a violation without certifying its absence",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: one suite plants a surface that names an unknown invariant, another plants an invariant record with no clauses, and the bundled data validates clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The invariant record, which every surface and document construct that asserts it cites",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-invariant-epi-terminate-on-three",
            "title": "Three-Condition Stop"
          }
        ],
        "title": "The invariants"
      },
      {
        "icon": "bi-signpost-split",
        "id": "the-failure-shapes",
        "intro": "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.",
        "subsections": [
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "A representation that no check reaches.",
                    "term": "Shape"
                  },
                  {
                    "description": "Declare the representation into a check's jurisdiction, or state in writing that it lies outside it.",
                    "term": "Fix"
                  },
                  {
                    "description": "[epi-reachable-check](/records/reasoning/invariant-epi-reachable-check)",
                    "term": "Breaks"
                  },
                  {
                    "description": "[Manual-Only Governance](/records/architecture/manual-only-governance), [Unobservable Failure](/records/architecture/unobservable-failure), [Untested Implementation](/records/lexicon/untested-implementation)",
                    "term": "Seen in"
                  },
                  {
                    "description": "None, because whether a representation is reachable is a property of the gate's jurisdiction, which no source rule sees",
                    "term": "Refused by rules"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the quality rules each shape names, which refuse its syntactic signature where one exists, the classification step of the verification substrate, which files every silent failure under a shape before a fix is chosen",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every source file the named rules lint, and every failure a check or a review classifies",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the linted source, a named rule or the shape's instances change",
                    "term": "Freshness"
                  },
                  {
                    "description": "A named rule fails the lint stage on the signature; the invariant each shape breaks is gated in every structured document that grounds it",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime observations that locate a failure, which are then filed under a shape",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a shape that names no invariant and no canon, and the bundled shapes validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The invariant the shape breaks, which the shape cites, while each named rule conforms to the shape's signature",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-failure-shape-no-reachable-check",
            "title": "No reachable check"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "A check that ran over an empty domain and reported a pass.",
                    "term": "Shape"
                  },
                  {
                    "description": "Report the population beside every rate, and confirm at start-up that every name the check uses resolves.",
                    "term": "Fix"
                  },
                  {
                    "description": "[epi-declared-domain](/records/reasoning/invariant-epi-declared-domain)",
                    "term": "Breaks"
                  },
                  {
                    "description": "[Silent Failure](/records/lexicon/silent-failure)",
                    "term": "Seen in"
                  },
                  {
                    "description": "empty-block, exception-handling",
                    "term": "Refused by rules"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the quality rules each shape names, which refuse its syntactic signature where one exists, the classification step of the verification substrate, which files every silent failure under a shape before a fix is chosen",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every source file the named rules lint, and every failure a check or a review classifies",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the linted source, a named rule or the shape's instances change",
                    "term": "Freshness"
                  },
                  {
                    "description": "A named rule fails the lint stage on the signature; the invariant each shape breaks is gated in every structured document that grounds it",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime observations that locate a failure, which are then filed under a shape",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a shape that names no invariant and no canon, and the bundled shapes validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The invariant the shape breaks, which the shape cites, while each named rule conforms to the shape's signature",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-failure-shape-empty-domain",
            "title": "Empty domain"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "A parent counted as read while its children were never read.",
                    "term": "Shape"
                  },
                  {
                    "description": "Subtract the read set from the child set and report what remains.",
                    "term": "Fix"
                  },
                  {
                    "description": "[epi-declared-domain](/records/reasoning/invariant-epi-declared-domain)",
                    "term": "Breaks"
                  },
                  {
                    "description": "None, because a read set is known only while the run executes",
                    "term": "Refused by rules"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the quality rules each shape names, which refuse its syntactic signature where one exists, the classification step of the verification substrate, which files every silent failure under a shape before a fix is chosen",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every source file the named rules lint, and every failure a check or a review classifies",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the linted source, a named rule or the shape's instances change",
                    "term": "Freshness"
                  },
                  {
                    "description": "A named rule fails the lint stage on the signature; the invariant each shape breaks is gated in every structured document that grounds it",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime observations that locate a failure, which are then filed under a shape",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a shape that names no invariant and no canon, and the bundled shapes validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The invariant the shape breaks, which the shape cites, while each named rule conforms to the shape's signature",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-failure-shape-spent-parent",
            "title": "Spent parent"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "A dependency created because two names share a word.",
                    "term": "Shape"
                  },
                  {
                    "description": "Join on the id the referent declares.",
                    "term": "Fix"
                  },
                  {
                    "description": "[epi-declared-dependency](/records/reasoning/invariant-epi-declared-dependency)",
                    "term": "Breaks"
                  },
                  {
                    "description": "[Hidden Dependency](/records/lexicon/hidden-dependency)",
                    "term": "Seen in"
                  },
                  {
                    "description": "None, because a join on spelling reads like any other string comparison in source",
                    "term": "Refused by rules"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the quality rules each shape names, which refuse its syntactic signature where one exists, the classification step of the verification substrate, which files every silent failure under a shape before a fix is chosen",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every source file the named rules lint, and every failure a check or a review classifies",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the linted source, a named rule or the shape's instances change",
                    "term": "Freshness"
                  },
                  {
                    "description": "A named rule fails the lint stage on the signature; the invariant each shape breaks is gated in every structured document that grounds it",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime observations that locate a failure, which are then filed under a shape",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a shape that names no invariant and no canon, and the bundled shapes validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The invariant the shape breaks, which the shape cites, while each named rule conforms to the shape's signature",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-failure-shape-edge-from-spelling",
            "title": "Edge from spelling"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "A node inside the graph that is trusted without a check, such as an exit code or a modification time.",
                    "term": "Shape"
                  },
                  {
                    "description": "Route the node through a check that can fail, and disclose what no check can reach.",
                    "term": "Fix"
                  },
                  {
                    "description": "[epi-verdict-is-representation](/records/reasoning/invariant-epi-verdict-is-representation)",
                    "term": "Breaks"
                  },
                  {
                    "description": "[Flaky Test Normalization](/records/architecture/flaky-test-normalization), [Mock Mirage](/records/architecture/mock-mirage), [Security Theater](/records/architecture/security-theater)",
                    "term": "Seen in"
                  },
                  {
                    "description": "error-handling",
                    "term": "Refused by rules"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the quality rules each shape names, which refuse its syntactic signature where one exists, the classification step of the verification substrate, which files every silent failure under a shape before a fix is chosen",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every source file the named rules lint, and every failure a check or a review classifies",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the linted source, a named rule or the shape's instances change",
                    "term": "Freshness"
                  },
                  {
                    "description": "A named rule fails the lint stage on the signature; the invariant each shape breaks is gated in every structured document that grounds it",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime observations that locate a failure, which are then filed under a shape",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a shape that names no invariant and no canon, and the bundled shapes validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The invariant the shape breaks, which the shape cites, while each named rule conforms to the shape's signature",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-failure-shape-trusted-leaf",
            "title": "Trusted leaf"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "A reshaped representation that dropped a distinction a later check needs.",
                    "term": "Shape"
                  },
                  {
                    "description": "Keep the distinction, and refuse at the writer anything the layout cannot express.",
                    "term": "Fix"
                  },
                  {
                    "description": "[epi-preserved-distinction](/records/reasoning/invariant-epi-preserved-distinction)",
                    "term": "Breaks"
                  },
                  {
                    "description": "[Null Semantics Drift](/records/architecture/null-semantics-drift), [Schema Drift](/records/architecture/schema-drift), [Silent Data Corruption](/records/architecture/silent-data-corruption)",
                    "term": "Seen in"
                  },
                  {
                    "description": "type-safety",
                    "term": "Refused by rules"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the quality rules each shape names, which refuse its syntactic signature where one exists, the classification step of the verification substrate, which files every silent failure under a shape before a fix is chosen",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every source file the named rules lint, and every failure a check or a review classifies",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the linted source, a named rule or the shape's instances change",
                    "term": "Freshness"
                  },
                  {
                    "description": "A named rule fails the lint stage on the signature; the invariant each shape breaks is gated in every structured document that grounds it",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime observations that locate a failure, which are then filed under a shape",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a shape that names no invariant and no canon, and the bundled shapes validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The invariant the shape breaks, which the shape cites, while each named rule conforms to the shape's signature",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-failure-shape-lossy-lowering",
            "title": "Lossy lowering"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "A check that reads a representation the run already changed.",
                    "term": "Shape"
                  },
                  {
                    "description": "Derive after the last mutator, and decide freshness by the fingerprint of the inputs and the code.",
                    "term": "Fix"
                  },
                  {
                    "description": "[epi-fresh-read](/records/reasoning/invariant-epi-fresh-read)",
                    "term": "Breaks"
                  },
                  {
                    "description": "[Cache Poisoning by Design](/records/architecture/cache-poisoning-by-design)",
                    "term": "Seen in"
                  },
                  {
                    "description": "None, because no catalogued rule refuses a cache keyed by time or by lifetime alone",
                    "term": "Refused by rules"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the quality rules each shape names, which refuse its syntactic signature where one exists, the classification step of the verification substrate, which files every silent failure under a shape before a fix is chosen",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every source file the named rules lint, and every failure a check or a review classifies",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the linted source, a named rule or the shape's instances change",
                    "term": "Freshness"
                  },
                  {
                    "description": "A named rule fails the lint stage on the signature; the invariant each shape breaks is gated in every structured document that grounds it",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime observations that locate a failure, which are then filed under a shape",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a shape that names no invariant and no canon, and the bundled shapes validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The invariant the shape breaks, which the shape cites, while each named rule conforms to the shape's signature",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-failure-shape-stale-read",
            "title": "Stale read"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "One question answered by two derivations that can drift apart.",
                    "term": "Shape"
                  },
                  {
                    "description": "Collapse them to one derivation, computed by the producer of the answer.",
                    "term": "Fix"
                  },
                  {
                    "description": "[epi-one-derivation](/records/reasoning/invariant-epi-one-derivation)",
                    "term": "Breaks"
                  },
                  {
                    "description": "[Duplicated Authority](/records/lexicon/duplicated-authority)",
                    "term": "Seen in"
                  },
                  {
                    "description": "duplicate-code",
                    "term": "Refused by rules"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the quality rules each shape names, which refuse its syntactic signature where one exists, the classification step of the verification substrate, which files every silent failure under a shape before a fix is chosen",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every source file the named rules lint, and every failure a check or a review classifies",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the linted source, a named rule or the shape's instances change",
                    "term": "Freshness"
                  },
                  {
                    "description": "A named rule fails the lint stage on the signature; the invariant each shape breaks is gated in every structured document that grounds it",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime observations that locate a failure, which are then filed under a shape",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a shape that names no invariant and no canon, and the bundled shapes validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The invariant the shape breaks, which the shape cites, while each named rule conforms to the shape's signature",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-failure-shape-two-derivations",
            "title": "Two derivations"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "A link below the certainty floor kept in a chain with a flag on it.",
                    "term": "Shape"
                  },
                  {
                    "description": "Remove the link from the chain.",
                    "term": "Fix"
                  },
                  {
                    "description": "[epi-weakest-link](/records/reasoning/invariant-epi-weakest-link)",
                    "term": "Breaks"
                  },
                  {
                    "description": "None, because the certainty of a link is a property of the chain, which no source rule sees",
                    "term": "Refused by rules"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the quality rules each shape names, which refuse its syntactic signature where one exists, the classification step of the verification substrate, which files every silent failure under a shape before a fix is chosen",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every source file the named rules lint, and every failure a check or a review classifies",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the linted source, a named rule or the shape's instances change",
                    "term": "Freshness"
                  },
                  {
                    "description": "A named rule fails the lint stage on the signature; the invariant each shape breaks is gated in every structured document that grounds it",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime observations that locate a failure, which are then filed under a shape",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a shape that names no invariant and no canon, and the bundled shapes validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The invariant the shape breaks, which the shape cites, while each named rule conforms to the shape's signature",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-failure-shape-weak-link-kept",
            "title": "Weak link kept"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "No observed failure read as proof that no failure exists.",
                    "term": "Shape"
                  },
                  {
                    "description": "Use the observation to locate failures, and leave the verdict on absence to a check.",
                    "term": "Fix"
                  },
                  {
                    "description": "[epi-observation-locates](/records/reasoning/invariant-epi-observation-locates)",
                    "term": "Breaks"
                  },
                  {
                    "description": "None, because the shape lies in how a report is read, not in source",
                    "term": "Refused by rules"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the quality rules each shape names, which refuse its syntactic signature where one exists, the classification step of the verification substrate, which files every silent failure under a shape before a fix is chosen",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every source file the named rules lint, and every failure a check or a review classifies",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the linted source, a named rule or the shape's instances change",
                    "term": "Freshness"
                  },
                  {
                    "description": "A named rule fails the lint stage on the signature; the invariant each shape breaks is gated in every structured document that grounds it",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime observations that locate a failure, which are then filed under a shape",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a shape that names no invariant and no canon, and the bundled shapes validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The invariant the shape breaks, which the shape cites, while each named rule conforms to the shape's signature",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-failure-shape-absence-certified-by-observation",
            "title": "Absence certified by observation"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "A run that stops because the model is confident, before completion, saturation and verification hold.",
                    "term": "Shape"
                  },
                  {
                    "description": "Stop only when the three conditions hold, or when the run is blocked on something outside it.",
                    "term": "Fix"
                  },
                  {
                    "description": "[epi-terminate-on-three](/records/reasoning/invariant-epi-terminate-on-three)",
                    "term": "Breaks"
                  },
                  {
                    "description": "None, because the shape lies in how a run decides to stop, not in source",
                    "term": "Refused by rules"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the quality rules each shape names, which refuse its syntactic signature where one exists, the classification step of the verification substrate, which files every silent failure under a shape before a fix is chosen",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every source file the named rules lint, and every failure a check or a review classifies",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the linted source, a named rule or the shape's instances change",
                    "term": "Freshness"
                  },
                  {
                    "description": "A named rule fails the lint stage on the signature; the invariant each shape breaks is gated in every structured document that grounds it",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime observations that locate a failure, which are then filed under a shape",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a shape that names no invariant and no canon, and the bundled shapes validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The invariant the shape breaks, which the shape cites, while each named rule conforms to the shape's signature",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-failure-shape-stop-on-confidence",
            "title": "Stop on confidence"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "A threshold set below what its population already meets, so the check it guards cannot fail until most of the population is gone.",
                    "term": "Shape"
                  },
                  {
                    "description": "Set the floor from the population as it stands, and plant a case below it to watch the check fail.",
                    "term": "Fix"
                  },
                  {
                    "description": "[epi-verdict-is-representation](/records/reasoning/invariant-epi-verdict-is-representation)",
                    "term": "Breaks"
                  },
                  {
                    "description": "None, because whether a floor can be reached is a property of the population, which no source rule sees",
                    "term": "Refused by rules"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the quality rules each shape names, which refuse its syntactic signature where one exists, the classification step of the verification substrate, which files every silent failure under a shape before a fix is chosen",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every source file the named rules lint, and every failure a check or a review classifies",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the linted source, a named rule or the shape's instances change",
                    "term": "Freshness"
                  },
                  {
                    "description": "A named rule fails the lint stage on the signature; the invariant each shape breaks is gated in every structured document that grounds it",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime observations that locate a failure, which are then filed under a shape",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a shape that names no invariant and no canon, and the bundled shapes validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The invariant the shape breaks, which the shape cites, while each named rule conforms to the shape's signature",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-failure-shape-unfailable-floor",
            "title": "Unfailable floor"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "A tool named as a verifier that reports no pass, no fail and no exit code, so what it examines has no check at all.",
                    "term": "Shape"
                  },
                  {
                    "description": "Give the tool a verdict and an exit code, or rename it to the probe it is.",
                    "term": "Fix"
                  },
                  {
                    "description": "[epi-reachable-check](/records/reasoning/invariant-epi-reachable-check)",
                    "term": "Breaks"
                  },
                  {
                    "description": "None, because whether a tool issues a verdict is a property of its output contract, which no source rule sees",
                    "term": "Refused by rules"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the quality rules each shape names, which refuse its syntactic signature where one exists, the classification step of the verification substrate, which files every silent failure under a shape before a fix is chosen",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every source file the named rules lint, and every failure a check or a review classifies",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the linted source, a named rule or the shape's instances change",
                    "term": "Freshness"
                  },
                  {
                    "description": "A named rule fails the lint stage on the signature; the invariant each shape breaks is gated in every structured document that grounds it",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime observations that locate a failure, which are then filed under a shape",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a shape that names no invariant and no canon, and the bundled shapes validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The invariant the shape breaks, which the shape cites, while each named rule conforms to the shape's signature",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-failure-shape-verdictless-verifier",
            "title": "Verdictless verifier"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "A kind of construct the index a family of checks reads never records, so every check over that index misses every construct of the kind.",
                    "term": "Shape"
                  },
                  {
                    "description": "Record the kind in the index, and confirm that a planted construct of the kind is reported.",
                    "term": "Fix"
                  },
                  {
                    "description": "[epi-preserved-distinction](/records/reasoning/invariant-epi-preserved-distinction)",
                    "term": "Breaks"
                  },
                  {
                    "description": "None, because an index's coverage of construct kinds is a property of its builder, which no source rule sees",
                    "term": "Refused by rules"
                  }
                ],
                "kind": "glossary"
              },
              {
                "kind": "text",
                "text": "How it is checked"
              },
              {
                "entries": [
                  {
                    "description": "the quality rules each shape names, which refuse its syntactic signature where one exists, the classification step of the verification substrate, which files every silent failure under a shape before a fix is chosen",
                    "term": "Checked by"
                  },
                  {
                    "description": "Every source file the named rules lint, and every failure a check or a review classifies",
                    "term": "Population"
                  },
                  {
                    "description": "A verdict stands until the linted source, a named rule or the shape's instances change",
                    "term": "Freshness"
                  },
                  {
                    "description": "A named rule fails the lint stage on the signature; the invariant each shape breaks is gated in every structured document that grounds it",
                    "term": "Refusal"
                  },
                  {
                    "description": "The runtime observations that locate a failure, which are then filed under a shape",
                    "term": "Observation"
                  },
                  {
                    "description": "Watched to fire and to accept: a suite plants a shape that names no invariant and no canon, and the bundled shapes validate clean",
                    "term": "Evidence"
                  },
                  {
                    "description": "The invariant the shape breaks, which the shape cites, while each named rule conforms to the shape's signature",
                    "term": "Authoritative side"
                  },
                  {
                    "description": "Not answered",
                    "term": "Depends on"
                  },
                  {
                    "description": "Not answered",
                    "term": "Shape it refuses"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "id": "reasoning-failure-shape-unindexed-construct-kind",
            "title": "Unindexed construct kind"
          }
        ],
        "title": "Failure shapes"
      },
      {
        "icon": "bi-signpost-split",
        "id": "the-uncovered-cells",
        "intro": "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.",
        "subsections": [
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "[identity](/records/reasoning/dimension-identity) through [temporal](/records/reasoning/lens-time)",
                    "term": "identity through temporal"
                  },
                  {
                    "description": "[identity](/records/reasoning/dimension-identity) through [spatial](/records/reasoning/lens-space)",
                    "term": "identity through spatial"
                  },
                  {
                    "description": "[identity](/records/reasoning/dimension-identity) through [statistical](/records/reasoning/lens-statistical)",
                    "term": "identity through statistical"
                  },
                  {
                    "description": "[identity](/records/reasoning/dimension-identity) through [frequency](/records/reasoning/lens-frequency)",
                    "term": "identity through frequency"
                  },
                  {
                    "description": "[identity](/records/reasoning/dimension-identity) through [sequential](/records/reasoning/lens-sequential)",
                    "term": "identity through sequential"
                  },
                  {
                    "description": "[identity](/records/reasoning/dimension-identity) through [relational](/records/reasoning/lens-relation)",
                    "term": "identity through relational"
                  },
                  {
                    "description": "[identity](/records/reasoning/dimension-identity) through [behavioral](/records/reasoning/lens-behavior)",
                    "term": "identity through behavioral"
                  },
                  {
                    "description": "[identity](/records/reasoning/dimension-identity) through [functional](/records/reasoning/lens-function)",
                    "term": "identity through functional"
                  },
                  {
                    "description": "[identity](/records/reasoning/dimension-identity) through [semantic](/records/reasoning/lens-meaning)",
                    "term": "identity through semantic"
                  },
                  {
                    "description": "[identity](/records/reasoning/dimension-identity) through [causal](/records/reasoning/lens-cause)",
                    "term": "identity through causal"
                  },
                  {
                    "description": "[identity](/records/reasoning/dimension-identity) through [predictive](/records/reasoning/lens-prediction)",
                    "term": "identity through predictive"
                  },
                  {
                    "description": "[identity](/records/reasoning/dimension-identity) through [anomaly](/records/reasoning/lens-anomaly)",
                    "term": "identity through anomaly"
                  },
                  {
                    "description": "[identity](/records/reasoning/dimension-identity) through [evolutionary](/records/reasoning/lens-change)",
                    "term": "identity through evolutionary"
                  },
                  {
                    "description": "[identity](/records/reasoning/dimension-identity) through [fractal](/records/reasoning/lens-fractal)",
                    "term": "identity through fractal"
                  },
                  {
                    "description": "[identity](/records/reasoning/dimension-identity) through [transformational](/records/reasoning/lens-transformation)",
                    "term": "identity through transformational"
                  },
                  {
                    "description": "[identity](/records/reasoning/dimension-identity) through [invariant](/records/reasoning/lens-invariant)",
                    "term": "identity through invariant"
                  },
                  {
                    "description": "[identity](/records/reasoning/dimension-identity) through [optimization](/records/reasoning/lens-optimization)",
                    "term": "identity through optimization"
                  },
                  {
                    "description": "[identity](/records/reasoning/dimension-identity) through [complexity](/records/reasoning/lens-complexity)",
                    "term": "identity through complexity"
                  },
                  {
                    "description": "[composition](/records/reasoning/dimension-composition) through [structural](/records/reasoning/lens-structure)",
                    "term": "composition through structural"
                  },
                  {
                    "description": "[composition](/records/reasoning/dimension-composition) through [temporal](/records/reasoning/lens-time)",
                    "term": "composition through temporal"
                  },
                  {
                    "description": "[composition](/records/reasoning/dimension-composition) through [spatial](/records/reasoning/lens-space)",
                    "term": "composition through spatial"
                  },
                  {
                    "description": "[composition](/records/reasoning/dimension-composition) through [statistical](/records/reasoning/lens-statistical)",
                    "term": "composition through statistical"
                  },
                  {
                    "description": "[composition](/records/reasoning/dimension-composition) through [frequency](/records/reasoning/lens-frequency)",
                    "term": "composition through frequency"
                  },
                  {
                    "description": "[composition](/records/reasoning/dimension-composition) through [sequential](/records/reasoning/lens-sequential)",
                    "term": "composition through sequential"
                  },
                  {
                    "description": "[composition](/records/reasoning/dimension-composition) through [relational](/records/reasoning/lens-relation)",
                    "term": "composition through relational"
                  },
                  {
                    "description": "[composition](/records/reasoning/dimension-composition) through [functional](/records/reasoning/lens-function)",
                    "term": "composition through functional"
                  },
                  {
                    "description": "[composition](/records/reasoning/dimension-composition) through [semantic](/records/reasoning/lens-meaning)",
                    "term": "composition through semantic"
                  },
                  {
                    "description": "[composition](/records/reasoning/dimension-composition) through [causal](/records/reasoning/lens-cause)",
                    "term": "composition through causal"
                  },
                  {
                    "description": "[composition](/records/reasoning/dimension-composition) through [predictive](/records/reasoning/lens-prediction)",
                    "term": "composition through predictive"
                  },
                  {
                    "description": "[composition](/records/reasoning/dimension-composition) through [anomaly](/records/reasoning/lens-anomaly)",
                    "term": "composition through anomaly"
                  },
                  {
                    "description": "[composition](/records/reasoning/dimension-composition) through [fractal](/records/reasoning/lens-fractal)",
                    "term": "composition through fractal"
                  },
                  {
                    "description": "[composition](/records/reasoning/dimension-composition) through [transformational](/records/reasoning/lens-transformation)",
                    "term": "composition through transformational"
                  },
                  {
                    "description": "[composition](/records/reasoning/dimension-composition) through [invariant](/records/reasoning/lens-invariant)",
                    "term": "composition through invariant"
                  },
                  {
                    "description": "[composition](/records/reasoning/dimension-composition) through [optimization](/records/reasoning/lens-optimization)",
                    "term": "composition through optimization"
                  },
                  {
                    "description": "[composition](/records/reasoning/dimension-composition) through [complexity](/records/reasoning/lens-complexity)",
                    "term": "composition through complexity"
                  },
                  {
                    "description": "[structure](/records/reasoning/dimension-structure) through [temporal](/records/reasoning/lens-time)",
                    "term": "structure through temporal"
                  },
                  {
                    "description": "[structure](/records/reasoning/dimension-structure) through [spatial](/records/reasoning/lens-space)",
                    "term": "structure through spatial"
                  },
                  {
                    "description": "[structure](/records/reasoning/dimension-structure) through [statistical](/records/reasoning/lens-statistical)",
                    "term": "structure through statistical"
                  },
                  {
                    "description": "[structure](/records/reasoning/dimension-structure) through [frequency](/records/reasoning/lens-frequency)",
                    "term": "structure through frequency"
                  },
                  {
                    "description": "[structure](/records/reasoning/dimension-structure) through [sequential](/records/reasoning/lens-sequential)",
                    "term": "structure through sequential"
                  },
                  {
                    "description": "[structure](/records/reasoning/dimension-structure) through [relational](/records/reasoning/lens-relation)",
                    "term": "structure through relational"
                  },
                  {
                    "description": "[structure](/records/reasoning/dimension-structure) through [behavioral](/records/reasoning/lens-behavior)",
                    "term": "structure through behavioral"
                  },
                  {
                    "description": "[structure](/records/reasoning/dimension-structure) through [functional](/records/reasoning/lens-function)",
                    "term": "structure through functional"
                  },
                  {
                    "description": "[structure](/records/reasoning/dimension-structure) through [semantic](/records/reasoning/lens-meaning)",
                    "term": "structure through semantic"
                  },
                  {
                    "description": "[structure](/records/reasoning/dimension-structure) through [causal](/records/reasoning/lens-cause)",
                    "term": "structure through causal"
                  },
                  {
                    "description": "[structure](/records/reasoning/dimension-structure) through [predictive](/records/reasoning/lens-prediction)",
                    "term": "structure through predictive"
                  },
                  {
                    "description": "[structure](/records/reasoning/dimension-structure) through [anomaly](/records/reasoning/lens-anomaly)",
                    "term": "structure through anomaly"
                  },
                  {
                    "description": "[structure](/records/reasoning/dimension-structure) through [evolutionary](/records/reasoning/lens-change)",
                    "term": "structure through evolutionary"
                  },
                  {
                    "description": "[structure](/records/reasoning/dimension-structure) through [fractal](/records/reasoning/lens-fractal)",
                    "term": "structure through fractal"
                  },
                  {
                    "description": "[structure](/records/reasoning/dimension-structure) through [transformational](/records/reasoning/lens-transformation)",
                    "term": "structure through transformational"
                  },
                  {
                    "description": "[structure](/records/reasoning/dimension-structure) through [invariant](/records/reasoning/lens-invariant)",
                    "term": "structure through invariant"
                  },
                  {
                    "description": "[structure](/records/reasoning/dimension-structure) through [optimization](/records/reasoning/lens-optimization)",
                    "term": "structure through optimization"
                  },
                  {
                    "description": "[structure](/records/reasoning/dimension-structure) through [complexity](/records/reasoning/lens-complexity)",
                    "term": "structure through complexity"
                  },
                  {
                    "description": "[relation](/records/reasoning/dimension-relation) through [structural](/records/reasoning/lens-structure)",
                    "term": "relation through structural"
                  },
                  {
                    "description": "[relation](/records/reasoning/dimension-relation) through [temporal](/records/reasoning/lens-time)",
                    "term": "relation through temporal"
                  },
                  {
                    "description": "[relation](/records/reasoning/dimension-relation) through [spatial](/records/reasoning/lens-space)",
                    "term": "relation through spatial"
                  },
                  {
                    "description": "[relation](/records/reasoning/dimension-relation) through [frequency](/records/reasoning/lens-frequency)",
                    "term": "relation through frequency"
                  },
                  {
                    "description": "[relation](/records/reasoning/dimension-relation) through [behavioral](/records/reasoning/lens-behavior)",
                    "term": "relation through behavioral"
                  },
                  {
                    "description": "[relation](/records/reasoning/dimension-relation) through [functional](/records/reasoning/lens-function)",
                    "term": "relation through functional"
                  },
                  {
                    "description": "[relation](/records/reasoning/dimension-relation) through [semantic](/records/reasoning/lens-meaning)",
                    "term": "relation through semantic"
                  },
                  {
                    "description": "[relation](/records/reasoning/dimension-relation) through [causal](/records/reasoning/lens-cause)",
                    "term": "relation through causal"
                  },
                  {
                    "description": "[relation](/records/reasoning/dimension-relation) through [predictive](/records/reasoning/lens-prediction)",
                    "term": "relation through predictive"
                  },
                  {
                    "description": "[relation](/records/reasoning/dimension-relation) through [anomaly](/records/reasoning/lens-anomaly)",
                    "term": "relation through anomaly"
                  },
                  {
                    "description": "[relation](/records/reasoning/dimension-relation) through [evolutionary](/records/reasoning/lens-change)",
                    "term": "relation through evolutionary"
                  },
                  {
                    "description": "[relation](/records/reasoning/dimension-relation) through [fractal](/records/reasoning/lens-fractal)",
                    "term": "relation through fractal"
                  },
                  {
                    "description": "[relation](/records/reasoning/dimension-relation) through [transformational](/records/reasoning/lens-transformation)",
                    "term": "relation through transformational"
                  },
                  {
                    "description": "[relation](/records/reasoning/dimension-relation) through [invariant](/records/reasoning/lens-invariant)",
                    "term": "relation through invariant"
                  },
                  {
                    "description": "[relation](/records/reasoning/dimension-relation) through [optimization](/records/reasoning/lens-optimization)",
                    "term": "relation through optimization"
                  },
                  {
                    "description": "[relation](/records/reasoning/dimension-relation) through [complexity](/records/reasoning/lens-complexity)",
                    "term": "relation through complexity"
                  },
                  {
                    "description": "[space](/records/reasoning/dimension-space) through [structural](/records/reasoning/lens-structure)",
                    "term": "space through structural"
                  },
                  {
                    "description": "[space](/records/reasoning/dimension-space) through [temporal](/records/reasoning/lens-time)",
                    "term": "space through temporal"
                  },
                  {
                    "description": "[space](/records/reasoning/dimension-space) through [spatial](/records/reasoning/lens-space)",
                    "term": "space through spatial"
                  },
                  {
                    "description": "[space](/records/reasoning/dimension-space) through [statistical](/records/reasoning/lens-statistical)",
                    "term": "space through statistical"
                  },
                  {
                    "description": "[space](/records/reasoning/dimension-space) through [frequency](/records/reasoning/lens-frequency)",
                    "term": "space through frequency"
                  },
                  {
                    "description": "[space](/records/reasoning/dimension-space) through [sequential](/records/reasoning/lens-sequential)",
                    "term": "space through sequential"
                  },
                  {
                    "description": "[space](/records/reasoning/dimension-space) through [relational](/records/reasoning/lens-relation)",
                    "term": "space through relational"
                  },
                  {
                    "description": "[space](/records/reasoning/dimension-space) through [behavioral](/records/reasoning/lens-behavior)",
                    "term": "space through behavioral"
                  },
                  {
                    "description": "[space](/records/reasoning/dimension-space) through [functional](/records/reasoning/lens-function)",
                    "term": "space through functional"
                  },
                  {
                    "description": "[space](/records/reasoning/dimension-space) through [semantic](/records/reasoning/lens-meaning)",
                    "term": "space through semantic"
                  },
                  {
                    "description": "[space](/records/reasoning/dimension-space) through [causal](/records/reasoning/lens-cause)",
                    "term": "space through causal"
                  },
                  {
                    "description": "[space](/records/reasoning/dimension-space) through [predictive](/records/reasoning/lens-prediction)",
                    "term": "space through predictive"
                  },
                  {
                    "description": "[space](/records/reasoning/dimension-space) through [anomaly](/records/reasoning/lens-anomaly)",
                    "term": "space through anomaly"
                  },
                  {
                    "description": "[space](/records/reasoning/dimension-space) through [evolutionary](/records/reasoning/lens-change)",
                    "term": "space through evolutionary"
                  },
                  {
                    "description": "[space](/records/reasoning/dimension-space) through [fractal](/records/reasoning/lens-fractal)",
                    "term": "space through fractal"
                  },
                  {
                    "description": "[space](/records/reasoning/dimension-space) through [transformational](/records/reasoning/lens-transformation)",
                    "term": "space through transformational"
                  },
                  {
                    "description": "[space](/records/reasoning/dimension-space) through [invariant](/records/reasoning/lens-invariant)",
                    "term": "space through invariant"
                  },
                  {
                    "description": "[space](/records/reasoning/dimension-space) through [optimization](/records/reasoning/lens-optimization)",
                    "term": "space through optimization"
                  },
                  {
                    "description": "[space](/records/reasoning/dimension-space) through [complexity](/records/reasoning/lens-complexity)",
                    "term": "space through complexity"
                  },
                  {
                    "description": "[time](/records/reasoning/dimension-time) through [structural](/records/reasoning/lens-structure)",
                    "term": "time through structural"
                  },
                  {
                    "description": "[time](/records/reasoning/dimension-time) through [spatial](/records/reasoning/lens-space)",
                    "term": "time through spatial"
                  },
                  {
                    "description": "[time](/records/reasoning/dimension-time) through [statistical](/records/reasoning/lens-statistical)",
                    "term": "time through statistical"
                  },
                  {
                    "description": "[time](/records/reasoning/dimension-time) through [frequency](/records/reasoning/lens-frequency)",
                    "term": "time through frequency"
                  },
                  {
                    "description": "[time](/records/reasoning/dimension-time) through [sequential](/records/reasoning/lens-sequential)",
                    "term": "time through sequential"
                  },
                  {
                    "description": "[time](/records/reasoning/dimension-time) through [relational](/records/reasoning/lens-relation)",
                    "term": "time through relational"
                  },
                  {
                    "description": "[time](/records/reasoning/dimension-time) through [behavioral](/records/reasoning/lens-behavior)",
                    "term": "time through behavioral"
                  },
                  {
                    "description": "[time](/records/reasoning/dimension-time) through [functional](/records/reasoning/lens-function)",
                    "term": "time through functional"
                  },
                  {
                    "description": "[time](/records/reasoning/dimension-time) through [semantic](/records/reasoning/lens-meaning)",
                    "term": "time through semantic"
                  },
                  {
                    "description": "[time](/records/reasoning/dimension-time) through [causal](/records/reasoning/lens-cause)",
                    "term": "time through causal"
                  },
                  {
                    "description": "[time](/records/reasoning/dimension-time) through [predictive](/records/reasoning/lens-prediction)",
                    "term": "time through predictive"
                  },
                  {
                    "description": "[time](/records/reasoning/dimension-time) through [anomaly](/records/reasoning/lens-anomaly)",
                    "term": "time through anomaly"
                  },
                  {
                    "description": "[time](/records/reasoning/dimension-time) through [evolutionary](/records/reasoning/lens-change)",
                    "term": "time through evolutionary"
                  },
                  {
                    "description": "[time](/records/reasoning/dimension-time) through [fractal](/records/reasoning/lens-fractal)",
                    "term": "time through fractal"
                  },
                  {
                    "description": "[time](/records/reasoning/dimension-time) through [transformational](/records/reasoning/lens-transformation)",
                    "term": "time through transformational"
                  },
                  {
                    "description": "[time](/records/reasoning/dimension-time) through [invariant](/records/reasoning/lens-invariant)",
                    "term": "time through invariant"
                  },
                  {
                    "description": "[time](/records/reasoning/dimension-time) through [optimization](/records/reasoning/lens-optimization)",
                    "term": "time through optimization"
                  },
                  {
                    "description": "[time](/records/reasoning/dimension-time) through [complexity](/records/reasoning/lens-complexity)",
                    "term": "time through complexity"
                  },
                  {
                    "description": "[state](/records/reasoning/dimension-state) through [temporal](/records/reasoning/lens-time)",
                    "term": "state through temporal"
                  },
                  {
                    "description": "[state](/records/reasoning/dimension-state) through [spatial](/records/reasoning/lens-space)",
                    "term": "state through spatial"
                  },
                  {
                    "description": "[state](/records/reasoning/dimension-state) through [statistical](/records/reasoning/lens-statistical)",
                    "term": "state through statistical"
                  },
                  {
                    "description": "[state](/records/reasoning/dimension-state) through [frequency](/records/reasoning/lens-frequency)",
                    "term": "state through frequency"
                  },
                  {
                    "description": "[state](/records/reasoning/dimension-state) through [relational](/records/reasoning/lens-relation)",
                    "term": "state through relational"
                  },
                  {
                    "description": "[state](/records/reasoning/dimension-state) through [behavioral](/records/reasoning/lens-behavior)",
                    "term": "state through behavioral"
                  },
                  {
                    "description": "[state](/records/reasoning/dimension-state) through [functional](/records/reasoning/lens-function)",
                    "term": "state through functional"
                  },
                  {
                    "description": "[state](/records/reasoning/dimension-state) through [semantic](/records/reasoning/lens-meaning)",
                    "term": "state through semantic"
                  },
                  {
                    "description": "[state](/records/reasoning/dimension-state) through [causal](/records/reasoning/lens-cause)",
                    "term": "state through causal"
                  },
                  {
                    "description": "[state](/records/reasoning/dimension-state) through [predictive](/records/reasoning/lens-prediction)",
                    "term": "state through predictive"
                  },
                  {
                    "description": "[state](/records/reasoning/dimension-state) through [anomaly](/records/reasoning/lens-anomaly)",
                    "term": "state through anomaly"
                  },
                  {
                    "description": "[state](/records/reasoning/dimension-state) through [evolutionary](/records/reasoning/lens-change)",
                    "term": "state through evolutionary"
                  },
                  {
                    "description": "[state](/records/reasoning/dimension-state) through [fractal](/records/reasoning/lens-fractal)",
                    "term": "state through fractal"
                  },
                  {
                    "description": "[state](/records/reasoning/dimension-state) through [transformational](/records/reasoning/lens-transformation)",
                    "term": "state through transformational"
                  },
                  {
                    "description": "[state](/records/reasoning/dimension-state) through [invariant](/records/reasoning/lens-invariant)",
                    "term": "state through invariant"
                  },
                  {
                    "description": "[state](/records/reasoning/dimension-state) through [optimization](/records/reasoning/lens-optimization)",
                    "term": "state through optimization"
                  },
                  {
                    "description": "[state](/records/reasoning/dimension-state) through [complexity](/records/reasoning/lens-complexity)",
                    "term": "state through complexity"
                  },
                  {
                    "description": "[change](/records/reasoning/dimension-change) through [structural](/records/reasoning/lens-structure)",
                    "term": "change through structural"
                  },
                  {
                    "description": "[change](/records/reasoning/dimension-change) through [temporal](/records/reasoning/lens-time)",
                    "term": "change through temporal"
                  },
                  {
                    "description": "[change](/records/reasoning/dimension-change) through [spatial](/records/reasoning/lens-space)",
                    "term": "change through spatial"
                  },
                  {
                    "description": "[change](/records/reasoning/dimension-change) through [statistical](/records/reasoning/lens-statistical)",
                    "term": "change through statistical"
                  },
                  {
                    "description": "[change](/records/reasoning/dimension-change) through [frequency](/records/reasoning/lens-frequency)",
                    "term": "change through frequency"
                  },
                  {
                    "description": "[change](/records/reasoning/dimension-change) through [sequential](/records/reasoning/lens-sequential)",
                    "term": "change through sequential"
                  },
                  {
                    "description": "[change](/records/reasoning/dimension-change) through [relational](/records/reasoning/lens-relation)",
                    "term": "change through relational"
                  },
                  {
                    "description": "[change](/records/reasoning/dimension-change) through [behavioral](/records/reasoning/lens-behavior)",
                    "term": "change through behavioral"
                  },
                  {
                    "description": "[change](/records/reasoning/dimension-change) through [functional](/records/reasoning/lens-function)",
                    "term": "change through functional"
                  },
                  {
                    "description": "[change](/records/reasoning/dimension-change) through [semantic](/records/reasoning/lens-meaning)",
                    "term": "change through semantic"
                  },
                  {
                    "description": "[change](/records/reasoning/dimension-change) through [causal](/records/reasoning/lens-cause)",
                    "term": "change through causal"
                  },
                  {
                    "description": "[change](/records/reasoning/dimension-change) through [predictive](/records/reasoning/lens-prediction)",
                    "term": "change through predictive"
                  },
                  {
                    "description": "[change](/records/reasoning/dimension-change) through [anomaly](/records/reasoning/lens-anomaly)",
                    "term": "change through anomaly"
                  },
                  {
                    "description": "[change](/records/reasoning/dimension-change) through [evolutionary](/records/reasoning/lens-change)",
                    "term": "change through evolutionary"
                  },
                  {
                    "description": "[change](/records/reasoning/dimension-change) through [fractal](/records/reasoning/lens-fractal)",
                    "term": "change through fractal"
                  },
                  {
                    "description": "[change](/records/reasoning/dimension-change) through [transformational](/records/reasoning/lens-transformation)",
                    "term": "change through transformational"
                  },
                  {
                    "description": "[change](/records/reasoning/dimension-change) through [invariant](/records/reasoning/lens-invariant)",
                    "term": "change through invariant"
                  },
                  {
                    "description": "[change](/records/reasoning/dimension-change) through [optimization](/records/reasoning/lens-optimization)",
                    "term": "change through optimization"
                  },
                  {
                    "description": "[change](/records/reasoning/dimension-change) through [complexity](/records/reasoning/lens-complexity)",
                    "term": "change through complexity"
                  },
                  {
                    "description": "[behavior](/records/reasoning/dimension-behavior) through [structural](/records/reasoning/lens-structure)",
                    "term": "behavior through structural"
                  },
                  {
                    "description": "[behavior](/records/reasoning/dimension-behavior) through [spatial](/records/reasoning/lens-space)",
                    "term": "behavior through spatial"
                  },
                  {
                    "description": "[behavior](/records/reasoning/dimension-behavior) through [statistical](/records/reasoning/lens-statistical)",
                    "term": "behavior through statistical"
                  },
                  {
                    "description": "[behavior](/records/reasoning/dimension-behavior) through [frequency](/records/reasoning/lens-frequency)",
                    "term": "behavior through frequency"
                  },
                  {
                    "description": "[behavior](/records/reasoning/dimension-behavior) through [sequential](/records/reasoning/lens-sequential)",
                    "term": "behavior through sequential"
                  },
                  {
                    "description": "[behavior](/records/reasoning/dimension-behavior) through [relational](/records/reasoning/lens-relation)",
                    "term": "behavior through relational"
                  },
                  {
                    "description": "[behavior](/records/reasoning/dimension-behavior) through [behavioral](/records/reasoning/lens-behavior)",
                    "term": "behavior through behavioral"
                  },
                  {
                    "description": "[behavior](/records/reasoning/dimension-behavior) through [functional](/records/reasoning/lens-function)",
                    "term": "behavior through functional"
                  },
                  {
                    "description": "[behavior](/records/reasoning/dimension-behavior) through [semantic](/records/reasoning/lens-meaning)",
                    "term": "behavior through semantic"
                  },
                  {
                    "description": "[behavior](/records/reasoning/dimension-behavior) through [causal](/records/reasoning/lens-cause)",
                    "term": "behavior through causal"
                  },
                  {
                    "description": "[behavior](/records/reasoning/dimension-behavior) through [predictive](/records/reasoning/lens-prediction)",
                    "term": "behavior through predictive"
                  },
                  {
                    "description": "[behavior](/records/reasoning/dimension-behavior) through [anomaly](/records/reasoning/lens-anomaly)",
                    "term": "behavior through anomaly"
                  },
                  {
                    "description": "[behavior](/records/reasoning/dimension-behavior) through [evolutionary](/records/reasoning/lens-change)",
                    "term": "behavior through evolutionary"
                  },
                  {
                    "description": "[behavior](/records/reasoning/dimension-behavior) through [fractal](/records/reasoning/lens-fractal)",
                    "term": "behavior through fractal"
                  },
                  {
                    "description": "[behavior](/records/reasoning/dimension-behavior) through [transformational](/records/reasoning/lens-transformation)",
                    "term": "behavior through transformational"
                  },
                  {
                    "description": "[behavior](/records/reasoning/dimension-behavior) through [invariant](/records/reasoning/lens-invariant)",
                    "term": "behavior through invariant"
                  },
                  {
                    "description": "[behavior](/records/reasoning/dimension-behavior) through [optimization](/records/reasoning/lens-optimization)",
                    "term": "behavior through optimization"
                  },
                  {
                    "description": "[behavior](/records/reasoning/dimension-behavior) through [complexity](/records/reasoning/lens-complexity)",
                    "term": "behavior through complexity"
                  },
                  {
                    "description": "[function](/records/reasoning/dimension-function) through [structural](/records/reasoning/lens-structure)",
                    "term": "function through structural"
                  },
                  {
                    "description": "[function](/records/reasoning/dimension-function) through [temporal](/records/reasoning/lens-time)",
                    "term": "function through temporal"
                  },
                  {
                    "description": "[function](/records/reasoning/dimension-function) through [spatial](/records/reasoning/lens-space)",
                    "term": "function through spatial"
                  },
                  {
                    "description": "[function](/records/reasoning/dimension-function) through [statistical](/records/reasoning/lens-statistical)",
                    "term": "function through statistical"
                  },
                  {
                    "description": "[function](/records/reasoning/dimension-function) through [frequency](/records/reasoning/lens-frequency)",
                    "term": "function through frequency"
                  },
                  {
                    "description": "[function](/records/reasoning/dimension-function) through [sequential](/records/reasoning/lens-sequential)",
                    "term": "function through sequential"
                  },
                  {
                    "description": "[function](/records/reasoning/dimension-function) through [relational](/records/reasoning/lens-relation)",
                    "term": "function through relational"
                  },
                  {
                    "description": "[function](/records/reasoning/dimension-function) through [functional](/records/reasoning/lens-function)",
                    "term": "function through functional"
                  },
                  {
                    "description": "[function](/records/reasoning/dimension-function) through [semantic](/records/reasoning/lens-meaning)",
                    "term": "function through semantic"
                  },
                  {
                    "description": "[function](/records/reasoning/dimension-function) through [causal](/records/reasoning/lens-cause)",
                    "term": "function through causal"
                  },
                  {
                    "description": "[function](/records/reasoning/dimension-function) through [predictive](/records/reasoning/lens-prediction)",
                    "term": "function through predictive"
                  },
                  {
                    "description": "[function](/records/reasoning/dimension-function) through [anomaly](/records/reasoning/lens-anomaly)",
                    "term": "function through anomaly"
                  },
                  {
                    "description": "[function](/records/reasoning/dimension-function) through [evolutionary](/records/reasoning/lens-change)",
                    "term": "function through evolutionary"
                  },
                  {
                    "description": "[function](/records/reasoning/dimension-function) through [fractal](/records/reasoning/lens-fractal)",
                    "term": "function through fractal"
                  },
                  {
                    "description": "[function](/records/reasoning/dimension-function) through [transformational](/records/reasoning/lens-transformation)",
                    "term": "function through transformational"
                  },
                  {
                    "description": "[function](/records/reasoning/dimension-function) through [invariant](/records/reasoning/lens-invariant)",
                    "term": "function through invariant"
                  },
                  {
                    "description": "[function](/records/reasoning/dimension-function) through [optimization](/records/reasoning/lens-optimization)",
                    "term": "function through optimization"
                  },
                  {
                    "description": "[function](/records/reasoning/dimension-function) through [complexity](/records/reasoning/lens-complexity)",
                    "term": "function through complexity"
                  },
                  {
                    "description": "[cause](/records/reasoning/dimension-cause) through [structural](/records/reasoning/lens-structure)",
                    "term": "cause through structural"
                  },
                  {
                    "description": "[cause](/records/reasoning/dimension-cause) through [temporal](/records/reasoning/lens-time)",
                    "term": "cause through temporal"
                  },
                  {
                    "description": "[cause](/records/reasoning/dimension-cause) through [spatial](/records/reasoning/lens-space)",
                    "term": "cause through spatial"
                  },
                  {
                    "description": "[cause](/records/reasoning/dimension-cause) through [statistical](/records/reasoning/lens-statistical)",
                    "term": "cause through statistical"
                  },
                  {
                    "description": "[cause](/records/reasoning/dimension-cause) through [frequency](/records/reasoning/lens-frequency)",
                    "term": "cause through frequency"
                  },
                  {
                    "description": "[cause](/records/reasoning/dimension-cause) through [sequential](/records/reasoning/lens-sequential)",
                    "term": "cause through sequential"
                  },
                  {
                    "description": "[cause](/records/reasoning/dimension-cause) through [relational](/records/reasoning/lens-relation)",
                    "term": "cause through relational"
                  },
                  {
                    "description": "[cause](/records/reasoning/dimension-cause) through [behavioral](/records/reasoning/lens-behavior)",
                    "term": "cause through behavioral"
                  },
                  {
                    "description": "[cause](/records/reasoning/dimension-cause) through [functional](/records/reasoning/lens-function)",
                    "term": "cause through functional"
                  },
                  {
                    "description": "[cause](/records/reasoning/dimension-cause) through [semantic](/records/reasoning/lens-meaning)",
                    "term": "cause through semantic"
                  },
                  {
                    "description": "[cause](/records/reasoning/dimension-cause) through [predictive](/records/reasoning/lens-prediction)",
                    "term": "cause through predictive"
                  },
                  {
                    "description": "[cause](/records/reasoning/dimension-cause) through [anomaly](/records/reasoning/lens-anomaly)",
                    "term": "cause through anomaly"
                  },
                  {
                    "description": "[cause](/records/reasoning/dimension-cause) through [evolutionary](/records/reasoning/lens-change)",
                    "term": "cause through evolutionary"
                  },
                  {
                    "description": "[cause](/records/reasoning/dimension-cause) through [fractal](/records/reasoning/lens-fractal)",
                    "term": "cause through fractal"
                  },
                  {
                    "description": "[cause](/records/reasoning/dimension-cause) through [transformational](/records/reasoning/lens-transformation)",
                    "term": "cause through transformational"
                  },
                  {
                    "description": "[cause](/records/reasoning/dimension-cause) through [invariant](/records/reasoning/lens-invariant)",
                    "term": "cause through invariant"
                  },
                  {
                    "description": "[cause](/records/reasoning/dimension-cause) through [optimization](/records/reasoning/lens-optimization)",
                    "term": "cause through optimization"
                  },
                  {
                    "description": "[cause](/records/reasoning/dimension-cause) through [complexity](/records/reasoning/lens-complexity)",
                    "term": "cause through complexity"
                  },
                  {
                    "description": "[meaning](/records/reasoning/dimension-meaning) through [structural](/records/reasoning/lens-structure)",
                    "term": "meaning through structural"
                  },
                  {
                    "description": "[meaning](/records/reasoning/dimension-meaning) through [temporal](/records/reasoning/lens-time)",
                    "term": "meaning through temporal"
                  },
                  {
                    "description": "[meaning](/records/reasoning/dimension-meaning) through [spatial](/records/reasoning/lens-space)",
                    "term": "meaning through spatial"
                  },
                  {
                    "description": "[meaning](/records/reasoning/dimension-meaning) through [statistical](/records/reasoning/lens-statistical)",
                    "term": "meaning through statistical"
                  },
                  {
                    "description": "[meaning](/records/reasoning/dimension-meaning) through [sequential](/records/reasoning/lens-sequential)",
                    "term": "meaning through sequential"
                  },
                  {
                    "description": "[meaning](/records/reasoning/dimension-meaning) through [relational](/records/reasoning/lens-relation)",
                    "term": "meaning through relational"
                  },
                  {
                    "description": "[meaning](/records/reasoning/dimension-meaning) through [behavioral](/records/reasoning/lens-behavior)",
                    "term": "meaning through behavioral"
                  },
                  {
                    "description": "[meaning](/records/reasoning/dimension-meaning) through [functional](/records/reasoning/lens-function)",
                    "term": "meaning through functional"
                  },
                  {
                    "description": "[meaning](/records/reasoning/dimension-meaning) through [causal](/records/reasoning/lens-cause)",
                    "term": "meaning through causal"
                  },
                  {
                    "description": "[meaning](/records/reasoning/dimension-meaning) through [predictive](/records/reasoning/lens-prediction)",
                    "term": "meaning through predictive"
                  },
                  {
                    "description": "[meaning](/records/reasoning/dimension-meaning) through [anomaly](/records/reasoning/lens-anomaly)",
                    "term": "meaning through anomaly"
                  },
                  {
                    "description": "[meaning](/records/reasoning/dimension-meaning) through [evolutionary](/records/reasoning/lens-change)",
                    "term": "meaning through evolutionary"
                  },
                  {
                    "description": "[meaning](/records/reasoning/dimension-meaning) through [fractal](/records/reasoning/lens-fractal)",
                    "term": "meaning through fractal"
                  },
                  {
                    "description": "[meaning](/records/reasoning/dimension-meaning) through [transformational](/records/reasoning/lens-transformation)",
                    "term": "meaning through transformational"
                  },
                  {
                    "description": "[meaning](/records/reasoning/dimension-meaning) through [invariant](/records/reasoning/lens-invariant)",
                    "term": "meaning through invariant"
                  },
                  {
                    "description": "[meaning](/records/reasoning/dimension-meaning) through [optimization](/records/reasoning/lens-optimization)",
                    "term": "meaning through optimization"
                  },
                  {
                    "description": "[meaning](/records/reasoning/dimension-meaning) through [complexity](/records/reasoning/lens-complexity)",
                    "term": "meaning through complexity"
                  },
                  {
                    "description": "[scale](/records/reasoning/dimension-scale) through [structural](/records/reasoning/lens-structure)",
                    "term": "scale through structural"
                  },
                  {
                    "description": "[scale](/records/reasoning/dimension-scale) through [temporal](/records/reasoning/lens-time)",
                    "term": "scale through temporal"
                  },
                  {
                    "description": "[scale](/records/reasoning/dimension-scale) through [spatial](/records/reasoning/lens-space)",
                    "term": "scale through spatial"
                  },
                  {
                    "description": "[scale](/records/reasoning/dimension-scale) through [frequency](/records/reasoning/lens-frequency)",
                    "term": "scale through frequency"
                  },
                  {
                    "description": "[scale](/records/reasoning/dimension-scale) through [sequential](/records/reasoning/lens-sequential)",
                    "term": "scale through sequential"
                  },
                  {
                    "description": "[scale](/records/reasoning/dimension-scale) through [relational](/records/reasoning/lens-relation)",
                    "term": "scale through relational"
                  },
                  {
                    "description": "[scale](/records/reasoning/dimension-scale) through [behavioral](/records/reasoning/lens-behavior)",
                    "term": "scale through behavioral"
                  },
                  {
                    "description": "[scale](/records/reasoning/dimension-scale) through [functional](/records/reasoning/lens-function)",
                    "term": "scale through functional"
                  },
                  {
                    "description": "[scale](/records/reasoning/dimension-scale) through [semantic](/records/reasoning/lens-meaning)",
                    "term": "scale through semantic"
                  },
                  {
                    "description": "[scale](/records/reasoning/dimension-scale) through [causal](/records/reasoning/lens-cause)",
                    "term": "scale through causal"
                  },
                  {
                    "description": "[scale](/records/reasoning/dimension-scale) through [predictive](/records/reasoning/lens-prediction)",
                    "term": "scale through predictive"
                  },
                  {
                    "description": "[scale](/records/reasoning/dimension-scale) through [evolutionary](/records/reasoning/lens-change)",
                    "term": "scale through evolutionary"
                  },
                  {
                    "description": "[scale](/records/reasoning/dimension-scale) through [fractal](/records/reasoning/lens-fractal)",
                    "term": "scale through fractal"
                  },
                  {
                    "description": "[scale](/records/reasoning/dimension-scale) through [transformational](/records/reasoning/lens-transformation)",
                    "term": "scale through transformational"
                  },
                  {
                    "description": "[scale](/records/reasoning/dimension-scale) through [invariant](/records/reasoning/lens-invariant)",
                    "term": "scale through invariant"
                  },
                  {
                    "description": "[scale](/records/reasoning/dimension-scale) through [optimization](/records/reasoning/lens-optimization)",
                    "term": "scale through optimization"
                  },
                  {
                    "description": "[scale](/records/reasoning/dimension-scale) through [complexity](/records/reasoning/lens-complexity)",
                    "term": "scale through complexity"
                  },
                  {
                    "description": "[probability](/records/reasoning/dimension-probability) through [structural](/records/reasoning/lens-structure)",
                    "term": "probability through structural"
                  },
                  {
                    "description": "[probability](/records/reasoning/dimension-probability) through [spatial](/records/reasoning/lens-space)",
                    "term": "probability through spatial"
                  },
                  {
                    "description": "[probability](/records/reasoning/dimension-probability) through [statistical](/records/reasoning/lens-statistical)",
                    "term": "probability through statistical"
                  },
                  {
                    "description": "[probability](/records/reasoning/dimension-probability) through [frequency](/records/reasoning/lens-frequency)",
                    "term": "probability through frequency"
                  },
                  {
                    "description": "[probability](/records/reasoning/dimension-probability) through [sequential](/records/reasoning/lens-sequential)",
                    "term": "probability through sequential"
                  },
                  {
                    "description": "[probability](/records/reasoning/dimension-probability) through [relational](/records/reasoning/lens-relation)",
                    "term": "probability through relational"
                  },
                  {
                    "description": "[probability](/records/reasoning/dimension-probability) through [behavioral](/records/reasoning/lens-behavior)",
                    "term": "probability through behavioral"
                  },
                  {
                    "description": "[probability](/records/reasoning/dimension-probability) through [functional](/records/reasoning/lens-function)",
                    "term": "probability through functional"
                  },
                  {
                    "description": "[probability](/records/reasoning/dimension-probability) through [semantic](/records/reasoning/lens-meaning)",
                    "term": "probability through semantic"
                  },
                  {
                    "description": "[probability](/records/reasoning/dimension-probability) through [causal](/records/reasoning/lens-cause)",
                    "term": "probability through causal"
                  },
                  {
                    "description": "[probability](/records/reasoning/dimension-probability) through [predictive](/records/reasoning/lens-prediction)",
                    "term": "probability through predictive"
                  },
                  {
                    "description": "[probability](/records/reasoning/dimension-probability) through [evolutionary](/records/reasoning/lens-change)",
                    "term": "probability through evolutionary"
                  },
                  {
                    "description": "[probability](/records/reasoning/dimension-probability) through [fractal](/records/reasoning/lens-fractal)",
                    "term": "probability through fractal"
                  },
                  {
                    "description": "[probability](/records/reasoning/dimension-probability) through [transformational](/records/reasoning/lens-transformation)",
                    "term": "probability through transformational"
                  },
                  {
                    "description": "[probability](/records/reasoning/dimension-probability) through [invariant](/records/reasoning/lens-invariant)",
                    "term": "probability through invariant"
                  },
                  {
                    "description": "[probability](/records/reasoning/dimension-probability) through [optimization](/records/reasoning/lens-optimization)",
                    "term": "probability through optimization"
                  },
                  {
                    "description": "[probability](/records/reasoning/dimension-probability) through [complexity](/records/reasoning/lens-complexity)",
                    "term": "probability through complexity"
                  },
                  {
                    "description": "[novelty](/records/reasoning/dimension-novelty) through [structural](/records/reasoning/lens-structure)",
                    "term": "novelty through structural"
                  },
                  {
                    "description": "[novelty](/records/reasoning/dimension-novelty) through [temporal](/records/reasoning/lens-time)",
                    "term": "novelty through temporal"
                  },
                  {
                    "description": "[novelty](/records/reasoning/dimension-novelty) through [spatial](/records/reasoning/lens-space)",
                    "term": "novelty through spatial"
                  },
                  {
                    "description": "[novelty](/records/reasoning/dimension-novelty) through [statistical](/records/reasoning/lens-statistical)",
                    "term": "novelty through statistical"
                  },
                  {
                    "description": "[novelty](/records/reasoning/dimension-novelty) through [frequency](/records/reasoning/lens-frequency)",
                    "term": "novelty through frequency"
                  },
                  {
                    "description": "[novelty](/records/reasoning/dimension-novelty) through [sequential](/records/reasoning/lens-sequential)",
                    "term": "novelty through sequential"
                  },
                  {
                    "description": "[novelty](/records/reasoning/dimension-novelty) through [relational](/records/reasoning/lens-relation)",
                    "term": "novelty through relational"
                  },
                  {
                    "description": "[novelty](/records/reasoning/dimension-novelty) through [behavioral](/records/reasoning/lens-behavior)",
                    "term": "novelty through behavioral"
                  },
                  {
                    "description": "[novelty](/records/reasoning/dimension-novelty) through [functional](/records/reasoning/lens-function)",
                    "term": "novelty through functional"
                  },
                  {
                    "description": "[novelty](/records/reasoning/dimension-novelty) through [semantic](/records/reasoning/lens-meaning)",
                    "term": "novelty through semantic"
                  },
                  {
                    "description": "[novelty](/records/reasoning/dimension-novelty) through [causal](/records/reasoning/lens-cause)",
                    "term": "novelty through causal"
                  },
                  {
                    "description": "[novelty](/records/reasoning/dimension-novelty) through [predictive](/records/reasoning/lens-prediction)",
                    "term": "novelty through predictive"
                  },
                  {
                    "description": "[novelty](/records/reasoning/dimension-novelty) through [evolutionary](/records/reasoning/lens-change)",
                    "term": "novelty through evolutionary"
                  },
                  {
                    "description": "[novelty](/records/reasoning/dimension-novelty) through [fractal](/records/reasoning/lens-fractal)",
                    "term": "novelty through fractal"
                  },
                  {
                    "description": "[novelty](/records/reasoning/dimension-novelty) through [transformational](/records/reasoning/lens-transformation)",
                    "term": "novelty through transformational"
                  },
                  {
                    "description": "[novelty](/records/reasoning/dimension-novelty) through [invariant](/records/reasoning/lens-invariant)",
                    "term": "novelty through invariant"
                  },
                  {
                    "description": "[novelty](/records/reasoning/dimension-novelty) through [optimization](/records/reasoning/lens-optimization)",
                    "term": "novelty through optimization"
                  },
                  {
                    "description": "[novelty](/records/reasoning/dimension-novelty) through [complexity](/records/reasoning/lens-complexity)",
                    "term": "novelty through complexity"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "title": "The uncovered cells"
          }
        ],
        "title": "The uncovered cells"
      },
      {
        "icon": "bi-signpost-split",
        "id": "the-maps",
        "intro": "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.",
        "subsections": [
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "logic-set-theory-axioms → structure → change → relationships → possibility → application",
                    "term": "Foundation sequence"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "title": "Foundation sequence"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "[algebra](/records/reasoning/math-type-algebra), geometry",
                    "term": "structure"
                  },
                  {
                    "description": "[analysis](/records/reasoning/math-type-analysis), dynamics",
                    "term": "change"
                  },
                  {
                    "description": "category-theory, [information-theory](/records/reasoning/math-type-information-theory)",
                    "term": "relationships"
                  },
                  {
                    "description": "[probability](/records/reasoning/math-type-probability), [computation](/records/reasoning/math-type-computation), complexity",
                    "term": "possibility"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "title": "Foundation layers"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "objects, relations, transformations, constraints, [emergence](/records/reasoning/substrate-node-emergence)",
                    "term": "generative"
                  },
                  {
                    "description": "entity, [relation](/records/reasoning/substrate-node-relation), state, [transformation](/records/reasoning/substrate-node-transformation), [constraint](/records/reasoning/substrate-node-constraint), [information](/records/reasoning/substrate-node-information), feedback, [emergence](/records/reasoning/substrate-node-emergence)",
                    "term": "systemic"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "title": "Invariant groups"
          },
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "detection, classification, explanation, prediction, generation",
                    "term": "Members"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "title": "Pattern operations"
          }
        ],
        "title": "The maps"
      },
      {
        "icon": "bi-signpost-split",
        "id": "the-groundings",
        "intro": "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.",
        "subsections": [
          {
            "blocks": [
              {
                "entries": [
                  {
                    "description": "[ver-evidence](/records/reasoning/node-ver-evidence) → Carries: an unverified claim carries no weight",
                    "term": "ver-evidence"
                  },
                  {
                    "description": "[constrain](/records/stage/constrain) → Lands on: [Governed Autonomous Plan Loop](/records/algorithms/governed-autonomous-plan-loop)",
                    "term": "constrain"
                  },
                  {
                    "description": "[derivation-loop](/records/reasoning/loop-derivation-loop) → Lands on: [Checklist Creation Kernel](/records/algorithms/checklist-creation-kernel)",
                    "term": "derivation-loop"
                  },
                  {
                    "description": "[derivation-loop](/records/reasoning/loop-derivation-loop) → Lands on: [checklist](/records/pag/template-checklist)",
                    "term": "derivation-loop"
                  }
                ],
                "kind": "glossary"
              }
            ],
            "title": "The groundings"
          }
        ],
        "title": "The groundings"
      }
    ]
  },
  "description": "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…",
  "id": "ontology",
  "label": "Reasoning",
  "tab": "reasoning",
  "title": "Reasoning — Ontology — Bane's Lab",
  "url": "https://banes-lab.com/ontology/reasoning"
}