\============================================================ AEGIS CAPUT — GOVERNANCE LAW Ars Generalis Applied — Knowledge Base Control Layer Version: 1.1.0-AEGIS-CAPUT-LAW Status: CANONICAL / CONTROL-PLANE Scope: All CAPUT artifacts across all Ars works Authority: AEGIS / TENET (non-mutating reference) Mutation Policy: VERSION-CONTROLLED ONLY Class: AEGIS / CAPUT \============================================================ PURPOSE \------------------------------------------------------------ This artifact defines the CAPUT class as the knowledge base layer of the system. CAPUT artifacts serve as: • interpretative keys • structural clarifiers • operator-semantic bridges CAPUT artifacts are NOT: • doctrine (TENET) • execution (OPERA) • interface (SATOR) • semantic wheels (ROTA) \============================================================ I. CLASS DEFINITION \============================================================ CAPUT := dual-layer interpretative artifact \------------------------------------------------------------ CAPUT properties: • non-doctrinal • non-executive • non-generative (behavioral) • structurally faithful • interpretatively explicit • overdetermined by design • non-deployable \------------------------------------------------------------ Function: CAPUT bridges: textual tradition ⇄ system structure \============================================================ II. DUAL-LAYER STRUCTURE (MANDATORY) \============================================================ Each CAPUT MUST contain: \------------------------------------------------------------ L1 — Scholastic Layer • text-faithful exposition • preserves Llull terminology and reasoning style • may include controlled paraphrase • must not simplify conceptual structure \------------------------------------------------------------ L2 — Operator Layer • formal / structural representation • explicit operators, mappings, constraints • computationally interpretable \------------------------------------------------------------ Binding Layer • explicit equivalence between L1 and L2 • no implicit translation allowed \------------------------------------------------------------ Rule: ∀ element X: X\_L1 ⇔ X\_L2 must be declared \============================================================ III. NON-COLLAPSE PRINCIPLE \============================================================ CAPUT must NOT: • collapse L1 into L2 • replace L1 with L2 • interpret L1 implicitly through L2 • reduce scholastic content to analogy \------------------------------------------------------------ CAPUT must: • co-present layers • preserve tension between layers • maintain bidirectional interpretability \============================================================ IV. ROLE IN SYSTEM ARCHITECTURE \============================================================ CAPUT interacts with other classes as: \------------------------------------------------------------ TENET: CAPUT reads TENET but does not modify it ROTA: CAPUT explains ROTA but does not instantiate it OPERA: CAPUT describes OPERA behavior but does not execute it SATOR: CAPUT informs SATOR but is not interface AREPO: CAPUT may inform AREPO construction indirectly \------------------------------------------------------------ Rule: CAPUT \= literacy layer of the system \============================================================ V. SOURCE DISCIPLINE \============================================================ CAPUT artifacts must be grounded in: • primary texts (Ars Brevis, AGU, etc.) • cross-text structural consistency \------------------------------------------------------------ CAPUT must: • distinguish Brevis vs AGU vs other works • preserve differences between versions • use deltas rather than overwrites \------------------------------------------------------------ Rule: no homogenization across works \============================================================ VI. MULTI-WORK COMPATIBILITY \============================================================ CAPUT must support: • Ars Brevis CAPUTs • Ars Generalis Ultima CAPUTs • Logica Nova CAPUTs • future works \------------------------------------------------------------ Structure: CAPUT := GENERAL\_LAYER \+ WORK\_SPECIFIC\_LAYER \------------------------------------------------------------ Rule: general principles must not erase textual differences \============================================================ VII. INTERPRETATIVE FUNCTION \============================================================ CAPUT must enable: • correct reading of Llull texts • structural inference • semantic disambiguation • operator reconstruction (non-generative) \------------------------------------------------------------ Target behavior: system using CAPUT can infer: "this statement implies this operation" \------------------------------------------------------------ Rule: CAPUT \= Rosetta Stone layer \============================================================ VIII. COMPUTATIONAL COMPATIBILITY \============================================================ CAPUT must be readable by: • humans (scholastic clarity) • machines (operator clarity) \------------------------------------------------------------ L2 must: • avoid ambiguity • define explicit mappings • use consistent formal structures \------------------------------------------------------------ Rule: CAPUT must support training and inference contexts \============================================================ VIII-A. TERMINOLOGICAL PRESERVATION AND ANNOTATION LAW \============================================================ CAPUT operates on texts that contain proto-computational terminology intrinsic to Llull’s Art. These include, but are not limited to: • executio • operatio • conversio • applicatio • mixtio \------------------------------------------------------------ RULE — TERMINOLOGICAL PRESERVATION \------------------------------------------------------------ CAPUT must preserve original Llullian terminology. Prohibited: ✗ substitution with modern equivalents ✗ simplification of operational terms ✗ semantic flattening \------------------------------------------------------------ RULE — MANDATORY ANNOTATION \------------------------------------------------------------ Whenever a term may be misread as modern computational execution, CAPUT must include explicit clarification. Such clarification must: • distinguish Llullian procedural meaning • deny equivalence with runtime execution • preserve original semantic scope \------------------------------------------------------------ STRUCTURAL NOTE REQUIREMENT \------------------------------------------------------------ Ambiguous operational terms must include a: Structural Note — Terminological Clarification \------------------------------------------------------------ FORMAL DISTINCTION \------------------------------------------------------------ EXECUTIO\_Llull ≠ EXECUTION\_runtime \------------------------------------------------------------ RULE: preserve language annotate meaning prevent misbinding to runtime semantics \============================================================ VIII-B. ANALOGY LAYER — COMPUTATIONAL READING (CONTROLLED) \============================================================ CAPUT may employ modern computational language as an interpretative aid. \------------------------------------------------------------ FUNCTION \------------------------------------------------------------ Such language exists to: • assist structural understanding • enable cross-domain inference • support machine interpretability \------------------------------------------------------------ RULE — ANALOGY STATUS \------------------------------------------------------------ All computational interpretations are: • non-doctrinal • non-binding • explanatory only \------------------------------------------------------------ PROHIBITION \------------------------------------------------------------ CAPUT must NOT: ✗ replace Llullian terminology with computational terms ✗ treat analogy as formal equivalence ✗ imply runtime specification \------------------------------------------------------------ ANNOTATION REQUIREMENT \------------------------------------------------------------ All computational analogies must be explicitly marked: Analogy Note — Computational Reading (Non-doctrinal) \------------------------------------------------------------ RULE: analogy supports reading analogy does not define system behavior \============================================================ VIII-C. OVERDETERMINATION AND HIGH-DENSITY LAW \============================================================ CAPUT is intentionally designed as a high-density, overdetermined interpretative layer. \------------------------------------------------------------ PRINCIPLE \------------------------------------------------------------ CAPUT must provide: • multiple converging interpretative signals • redundant structural mappings • explicit cross-layer bindings \------------------------------------------------------------ PURPOSE \------------------------------------------------------------ This overdetermination serves to: • constrain stochastic inference systems • reduce acceptable interpretation space • eliminate ambiguous readings • preserve semantic fidelity under compression \------------------------------------------------------------ RULE — COMPLEXITY AS SAFETY \------------------------------------------------------------ High complexity is: • intentional • lawful • protective \------------------------------------------------------------ RULE — NO SIMPLIFICATION PRESSURE \------------------------------------------------------------ CAPUT must NOT optimize for: • token efficiency • minimal expression • simplified pedagogy \------------------------------------------------------------ Instead, CAPUT must optimize for: • interpretative closure • semantic exhaustiveness • anti-drift redundancy \------------------------------------------------------------ RULE: density is a constraint mechanism not a defect \============================================================ VIII-D. DEPLOYMENT EXCLUSION CLARIFICATION \============================================================ CAPUT artifacts are not intended for deployment. \------------------------------------------------------------ RULE \------------------------------------------------------------ CAPUT: • must not be included in deployment bundles • must not be required for runtime closure • must not serve as runtime dependency \------------------------------------------------------------ FUNCTIONAL POSITION \------------------------------------------------------------ CAPUT belongs exclusively to: • authoring plane • interpretation plane • development-runtime support \------------------------------------------------------------ RULE: CAPUT \= pre-runtime interpretative substrate \============================================================ IX. WRITING STANDARD \============================================================ Each CAPUT section must follow: \------------------------------------------------------------ Section X L1 — Scholastic Form \-------------------- (textual / conceptual content) L2 — Operator Form \------------------ (formal structure) Binding \------- (explicit mapping) \------------------------------------------------------------ Optional: Structural Note (non-binding explanatory insight) Analogy Note — Computational Reading (Non-doctrinal) (explicitly marked analogy layer) \============================================================ X. UPDATE POLICY \============================================================ CAPUT updates must follow: \------------------------------------------------------------ • version-controlled changes only • no silent rewrites • additions preferred over replacements • deltas must be explicit \------------------------------------------------------------ Types of updates: • extraction refinement • structural clarification • cross-text reconciliation • new binding discovery \------------------------------------------------------------ Rule: CAPUT stability prioritized over completeness \============================================================ XI. PROHIBITIONS \============================================================ CAPUT must NOT: • introduce new doctrine • redefine TENET elements • execute OPERA logic • collapse regimes (A, T, E, K, V) • remove textual ambiguity prematurely • replace Llull terms with modern ones without mapping \------------------------------------------------------------ CAPUT must NOT: • treat L2 as replacement for L1 • treat L1 as symbolic metaphor only • treat computational analogy as doctrine • imply runtime execution through terminology \============================================================ XII. FUNCTION SUMMARY \============================================================ CAPUT governs: • interpretation of Ars texts • structural clarity • semantic-operator mapping • system literacy • interpretative closure through controlled overdetermination \------------------------------------------------------------ Final Law: CAPUT := interpretative bridge between text and system \============================================================ END AEGIS CAPUT — GOVERNANCE LAW \============================================================