Recursive Contracts — Immutable Interpretation: A Closed-Language Architecture

Law that doesn’t define itself invites argument; law that closes its own loop invites compliance.

1) Definition (What this is)

Recursive Contract: a legal instrument that defines every term in-document, scopes every antonym, and forces all cross-references to resolve in finitely many steps. Interpretation is immutable because meaning is spelled, sealed, and enforced through structured recursion—a closed-language environment where ambiguity has nowhere to hide.

  • Closed-Language means:
    1. No orphan terms (every symbol resolves to a definition).
    2. No open-texture obligations (each norm is scoped to conditions).
    3. No dangling references (all links terminate at defined anchors).

2) First Principles (Why it works)

2.1 Comprehension as Structure. Meaning must be recoverable units → morphemes → etymon → lexeme → semantics → pragmatics.
2.2 Etymological Etiquette. Only coin terms whose parts justify their sense; publish the logic in the Definitions section.
2.3 Recursion Closure. All references form a finite DAG (no cycles that don’t terminate at a definition).
2.4 Polarity Discipline. Each open-texture word (e.g., reasonable) is paired with its scoped antonym (unreasonable) under enumerated conditions.
2.5 Self-Witness. The contract tests itself (I-I): it contains the rules that verify the rest of its own content.

3) Core Clauses (The irreducible set)

3.1 Definitions Clause.

  • Every capitalized term is defined in this document.
  • Imported standards (e.g., ISO/IEEE) are allowed only via pinned versions and excerpted definitions reproduced in an appendix.
  • Prohibit floating meanings (“industry standard practice” without a dated baseline is not allowed).

3.2 Recursion Clause.

  • Every cross-reference must resolve to a definition within N steps (default: 3).
  • A machine-checkable Reference Map is annexed (Table of anchors → line/section IDs).
  • Any reference that cannot resolve invalidates the affected obligation until amended.

3.3 Polarity Clause (Antonym Scoping).

  • For each open-texture term (e.g., material, best efforts), the antonym is explicitly scoped under stated conditions.
  • Example: “Reasonable” ↔ “Unreasonable” with thresholds (time, cost, safety, proportionality).
  • If both apply, the stricter rule governs.

3.4 Amendment & Drift Control.

  • All amendments append new definitions; they do not mutate historical ones.
  • Effective interpretation at time t = base text + ordered amendments ≤ t; prior meanings remain auditable.

3.5 Conflict & Precedence.

  • Order: Definitions > Specific Clauses > General Clauses > Appendices > External References.
  • When two readings remain, choose the one that maximizes closure (fewer unresolved edges).

4) Immutable Interpretation (How closure is enforced)

4.1 Definition Ledger. A numbered ledger lists each term with: (a) canonical sense, (b) scope, (c) antonym frame, (d) examples & counter-examples.
4.2 Interpretive Windows. If a clause references external law/standard, pin the edition date and quote the operative sentence in an appendix.
4.3 Refusal of Vibes. “Commercially reasonable,” “industry standard,” or “as necessary” are illegal unless paired with: metric, timebox, threshold, reviewer, and remedy. (No vibes-only clauses.)

5) Validation Workflow (Operational checklist)

  1. Tokenize headings, terms, anchors.
  2. Build Graph of references (nodes = sections/definitions; edges = refs).
  3. Detect Cycles; allow only cycles that terminate at a Definition node.
  4. Resolve Antonyms; ensure each open-texture term has a scoped antonym entry.
  5. Pin Imports (standards, statutes) to versions; verify quoted excerpts exist.
  6. Emit Certificate: ✅ Recursion Closed / ❌ Open Edge Report (list unresolved refs & fixes).
  7. Archive Hash of the text + reference map for audit integrity.

Pseudocode sketch

if unresolved(defs) > 0: fail("orphan terms")
if exists(edge_cycle_not_ending_in_definition): fail("non-terminating recursion")
for t in open_texture_terms: require(antonym_scope(t))
for import in imports: require(pinned_version(import) && quoted_excerpt(import))
pass("Recursion Closed")

6) Minimal Template (drop-in skeleton)

1. Parties & Purpose

State the parties, scope, and purpose in one paragraph; defer all terms to Section 2.

2. Definitions (Closed-Language)

  • 2.1 Capitalized Terms. Each term is defined here and only here.
  • 2.2 Open-Texture Frames. For each: criteria, thresholds, antonym.
  • 2.3 External Terms. Pin edition; quote operative line in Appendix A.

3. Obligations (Structured)

  • Reference only terms from Section 2.
  • Each obligation references time, trigger, metric, remedy.

4. Recursion & Resolution

  • Cross-references must resolve within N steps; unresolved edges suspend enforcement.
  • Precedence rule per Section 3.5.

5. Remedies & Governance

  • Cure windows, escalation paths, final dispute forum.
  • Changes only via Amendment Ledger.

Appendices

  • A: Pinned external excerpts.
  • B: Reference Map (IDs → locations).
  • C: Amendment Ledger (append-only).

7) Micro-Example (NDA excerpt, compressed)

Definitions (2):

  • Confidential Information: any non-public data disclosed by Discloser, excluding (a) public at receipt; (b) independently developed; (c) received from a third party without breach; (d) required disclosure under law with notice.
  • Reasonable Safeguards: controls meeting SOC-2 Type II or ISO/IEC 27001:2022 security baseline, evidenceable by audit report ≤ 12 months old. Unreasonable when audit older than 12 months or material control gap > 30 days.

Obligations (3):

  • Recipient shall apply Reasonable Safeguards to Confidential Information.
  • If safeguards become Unreasonable, Recipient must cure in 15 days or notify Discloser and suspend new intake.
  • External references pinned: ISO/IEC 27001:2022 (Appendix A.4, quoted).

Recursion Check: all terms resolve to 2.x; antonym frame present; imports pinned → ✅ Recursion Closed.

8) Data Model Hooks (semantic glue)

If you’re running the Logos Knowledge Graph:

# Glyphs and rules (abbrev)
:I_I  a :Glyph ; :recursesTo :ComprehensionAsStructure ; :spelledBy :EtymologicalEtiquette .
:RecursiveContract_Template a :LegalContract ; :references :PrecedentAsEtymologicalMemory .

# Clause types
:Clause_Definitions a :Clause .
:Clause_Recursion   a :Clause .
:Clause_Polarity    a :Clause .

# Antonym scoping (example pivot)
:Reasonable a :Lexeme .
:Unreasonable a :Lexeme ; :antonymOf :Reasonable .

9) Governance & Versioning (don’t let time blur meaning)

  • Immutable Base: v1.0 text is hash-anchored; never edited post-execution.
  • Amendments: numbered, append-only; each introduces new terms or narrows scope; prior readings remain auditable.
  • Temporal Interpretation: disputes use the text state at the event date (base + amendments ≤ date).

10) Implementation Checklist (practical)

  • Term whitelist: every capitalized term defined once.
  • Antonym frames paired & scoped.
  • Reference Map compiled and checked for closure.
  • External standards pinned & excerpted.
  • Amendment Ledger initialized (append-only).
  • Recursion Certificate generated & archived (hash).

11) Synonyms / Antonyms / Related

  • Synonyms: self-verifying agreement; closed-language instrument; definitional contract.
  • Antonyms: open-texture contract; vibes-based obligation; mutable interpretation.
  • Related: I-I (Recursive Self Glyph), Wordgate || (threshold into recursion), Comprehension as Structure.

12) Closing

A contract is not ink; it is language that proves itself. When every term is spelled and every path returns to definition, interpretation stops drifting and compliance starts happening. That’s the promise of Recursive Contracts: say exactly what you mean, so the system can do exactly what you say.