# Coherence Is Not Truth

*Auditable Holonomy and Constructive Repair in Populations of Divergent
Sparse Block Codebooks*

*Published as a note at taniwha.ai/research; the internal record is private
and its verification is published beside the note.*

Timothy Marsden, Matthew Collecutt, James Marsden — Taniwha AI

**Note v1.2 — 2026-09-05.** Working note. The experimental record is frozen
at tag `fractal-tribalism-v1.2` of a private repository. Every deterministic
claim-bearing figure is asserted exactly by a test in that record — the main
pin suite, with §6.5's counts, §7.4's, §8's, §9's and §11's each pinned in
their own suite — and the run of the whole suite from a fresh clone at the
tag is Receipt B of the verification receipts published beside this note;
the record's artefact identities are in the artefact manifest;
machine-local timings are the only unpinned figures; see Appendix A.

---

## Abstract

Populations of locally adapting communicating agents diverge: vocabularies
grow apart and shared words drift. The mathematics we use — cycle
consistency, decoding uniqueness, holonomy as a diagnostic — is established;
what is new is the executable combination of divergent codebooks, auditable
residuals, certified attribution, constructive map repair and refusal, with
its boundaries measured. We show three things in a small, fully
inspectable setting. First, pairwise-flat translation relationships can
conceal a population-level inconsistency, and in a sparse-block-code
realization (codewords as K-tuples of slot indices, K=64 blocks ×
B=16,384 slots, per-block modular binding) the holonomy of a loop of maps is
not a scalar alarm but an exact, block-indexed symbolic residual — farmed
from explicitly specified drift and contact rules, auditable block by block,
and reusable downstream. Second, that residual supports constructive repair
within explicit, proved-or-measured boundaries: exact comprehension is
restorable precisely when production was injective on the tokens in play
(Proposition 1 — a merger is irrecoverable, an equally severe swap fully
repairable); an edge carrying direct anchor evidence refuses automatic
repair rather than trade calibration for coherence; and multi-loop
attribution lifts that refusal under the certified condition that per-token
corruption support stays below half the contact graph's edge connectivity
(Proposition 2 — one triangle can never attribute; for a single corruption on
an emergent contact graph the boundary is exact and local: the connectivity
of the accused edge's endpoints, Proposition 3). Third, a deterministic task economy prices
the design thesis that divergence should be farmed rather than fought:
instrumented divergence beats both forced uniformity and uninstrumented
divergence precisely within a measured, non-empty window of relative
bandwidth cost, and loses honestly on either side of it. A preregistered
2 × 2 × 2 over one staged assertion path (translation × grounding ×
authority) then shows the three layers compose without impersonation, that
eligible repair restores the intended act without displacing the fault (0 of
36 seeds moved), and that attribution is exact inside its proved boundary
and confidently wrong outside it — the primary rate inside the boundary
being observed at 1.0 but unsupported at the preregistered precision. All
state is sparse, deterministic, and serializable as
subject–predicate–object triples; the frozen seed codebook contract is
untouched throughout.

---

## 1. Introduction

Multi-agent systems live with a quiet tension. Local adaptation — each agent
compressing what it repeatedly encounters — is where efficiency comes from,
and it pulls representations apart; cooperation needs those representations to
stay mutually interpretable. The standard resolution imposes homogeneity: one
ontology, one embedding space, shared weights, a central vocabulary. This
paper works out the other resolution in a small, fully inspectable setting:
let representations diverge, and move the interpretability burden onto
explicit machinery *between* agents — translation maps that are ordinary
data, a genealogy recording what every minted word compresses, and a
population-level consistency instrument whose readings are exact enough to
act on. We build the smallest system in which that machinery can be tested
honestly, and report what it can and cannot do.

The thesis, in three claims:

1. **Divergence should be farmed, not fought.** Compression into local dialects
   is what makes a niche efficient (iterated-learning literature); the design
   problem is not preventing divergence but instrumenting it. Once a design
   proposition the experiments merely motivated, this now carries a price
   (§8): in a task economy over this substrate, instrumented divergence
   beats both monoculture and uninstrumented divergence exactly within a
   measured window of relative bandwidth cost — and outside the window the
   proposition is false, in a direction the experiment names. The
   unconditional slogan remains a slogan; the windowed claim is a result.
2. **Pairwise consistency is a provably incomplete instrument.** Loop holonomy
   over ≥3 agents detects a class of misalignment — disagreement about
   *register structure* between tribes — that no 2-cycle can see, because every
   2-cycle inside the loop is flat by construction (§4, §6).
3. **In a sparse block code, the defect is the diagnosis and the correction.**
   Because binding is per-block modular addition, holonomy is an integer vector
   whose nonzero blocks localize the disagreement and whose values read it back
   with sign. Abduction reduces to subtracting a baseline; repair reduces to
   installing the negated excess on an edge free of direct evidence for that
   token — and to a recorded refusal on an edge that is not (§7).

Measured highlights, every figure pinned in CI (Appendix A): the farmed
3-loop defect equals the difference of two tribes' register splits exactly,
at all of seeds 1–32 (§6.2); the closed-loop repairs are exact, not
statistical — comprehension 0.667 → 1.0 (n=3) on the drift channel and
0.75 → 1.0 (n=4) on the growth channel (§7); an N-agent harness detects
injected missing-anchor quirks exactly over fundamental cycle bases up to
N=100 agents and 101 cycles (§6.5); multi-loop attribution recovers planted
corruption exactly, and certified, on λ=5 contact graphs at N=12 and N=30,
while one triangle and a λ=2 ring are refused (§7.4); the task economy's
farming window is 0.155 < w < 0.611 at the reference seed and tariff, with
0.2556 < w < 0.4831 common to all sixteen seeds tried (§8); and on an
emergent contact graph grown by a prefix-tribe cellular automaton,
attributability is decided exactly by local edge connectivity — λ(u,v) = 2
ambiguous 23/23, λ(u,v) ≥ 3 unique 80/80, zero exceptions across four
seeds (Proposition 3, §9).

The name: *fractal tribalism*. Tribes schism, and each schism's layer becomes
the base of the next (§5); meanwhile two tribes that compress the same surface
in different orders hold the same word with different parses — divergence
appears at every scale of the genealogy, and the disagreement is structural
(nesting), not superficial (surface), which we measure (§6.3). "Fractal" here
denotes this recursive nested schism, as metaphor; we establish no scale
invariance, scaling law, or fractal dimension, and make no geometric or
statistical fractality claim.

![Figure 1 — (a) pairwise-flat maps close a dirty 3-loop; the per-token excess
is a sparse signed 64-block vector, and installing its negation on the
listener's own evidence-free edge lands its expectation on the speaker's
actual production. (b) The repairability boundary: a production merger is
irrecoverable, an equally severe swap fully repairable
(Proposition 1).](figures/fractal-tribalism-fig1.svg)

**Figure 1.** The paper in one picture. *(a)* Three agents whose pairwise
translation maps are flat around every 2-cycle while the 3-loop closes dirty;
the per-token excess Eₜ is a sparse, signed, block-indexed residual — an
auditable object, not an alarm — and routing −Eₜ onto the one edge with no
direct evidence for the quirked token repairs comprehension exactly (§7.2).
*(b)* Proposition 1's boundary: repair restores exactly what production
preserved.

## 2. Related Work

*(The three closest 2026 near-neighbours in the holonomy line were
independently verified during the fifth review round, and their publication
status re-checked in the sixth: Sevetlidis & Pavlidis is now published at
ICLR 2026; Javidnia and Olivieri & Hernández remain preprints. The families
added at the 2026-09-05 prior-art pass were verified bibliographically before
publication; the search record ships beside this note. Full citations in the
References.)*

**Group synchronization and cycle-edge message passing.** The mathematics of
our instrument belongs to gauge theory and group synchronization, and its
localisation principle is not ours. That pairwise consistency does not imply
global cycle consistency is classical there (Singer 2011); our loop defect is
"frustration" in that language, restricted to the abelian case; and the
principle that a cycle's inconsistency locates the corruption on its edges is
cycle-edge message passing — CEMP (Lerman & Shi, *Found. Comput. Math.*
22:1665–1741, 2022; arXiv:1912.11347), which estimates per-edge corruption
levels from cycle-consistency information under noise. Its sharpest form —
with one corrupted element, a cycle's inconsistency gives that element's
corruption — is stated starkly in higher-order group synchronization
(Duncan & Kileel, *Res. Math. Sci.* 13(2):48, 2026; arXiv:2505.21932), and
Cycle-Sync (Li, Shi & Lerman, NeurIPS 2025; arXiv:2511.02329) carries the
strongest deterministic guarantee that cycle consistency alone suffices for
exact recovery. Against that background our
propositions are standard and are labelled so where they appear:
Proposition 2 is bounded-distance decoding uniqueness for the graph's cut
code over Z_B^K, Proposition 3 is its local form, and Proposition 1 is the
definition of decodability. Two 2026 works reuse a loop residual as a
diagnostic: Mishra's cohomological theory of context preservation in agentic
reasoning (arXiv:2608.11252) takes a harmonic residual over loops of contexts
to gate abstention — single agent, no map repair — and the Cartan-Topos
Protocol (Hernández & Sánchez-Soto, arXiv:2606.00714) runs sheaf-Laplacian
consensus with logical holonomy as a diagnostic, not a map repair. What differs here, in
one sentence: edge-level attribution with a local λ(u,v) ≥ 3 boundary, a
certificate kept beside the answer, and constructive repair of the map
itself — the synchronization methods emit estimates without abstention, and
the residual-as-diagnostic works abstain without attributing or repairing.

**Representation holonomy and sheaves.** Two 2026 works are the nearest
neighbours on the holonomy side: Sevetlidis & Pavlidis define representation
holonomy as a loop-defect statistic on a single model, and Javidnia builds a
sheaf atlas over a frozen LLM with holonomy and obstruction decomposition,
including a spanning-tree gauge identity. Neither has discrete codebooks, a
population, or a repair operator. From the sheaf-theoretic line (Robinson;
Hansen & Ghrist; Olivieri & Hernández's obstruction-triggered abductive
extension; sheaf-theoretic planning for swarms) we borrow vocabulary
informally: the per-token excess field plays the role of a gluing obstruction
and repair removes it; we do not construct a Čech complex over the contact
topology, and until we do the correspondence is an analogy, not a theorem.

**The substrate.** Our substrate comes from vector-symbolic architectures.
The VSA/HDC surveys of Kleyko et al. fix the vocabulary; resonator networks
(Frady, Kent et al.) factor bound products over *known* codebooks, which is
why our deferred missing-facts case (§12)points at them; and sparse block
codes (Laiho et al.; the Frady/Kleyko line) supply the specific algebra we
lean on — per-block modular binding is native there, not our invention. The
closest single system is VSAIT (Theiss et al., ECCV 2022): binding-based
translation between two domains with a single unidirectional inversion
constraint in a shared hyperspace. Our setting differs architecturally — a
population, deliberately divergent codebooks, ≥3-agent loops, and repair —
and the comparison we draw is of signal shape, not benchmarked performance.

**Emergent communication and divergence.** The dynamics we farm are the
subject of emergent communication: divergent dialects and language drift
(Lazaridou et al.), contact linguistics among agent communities (Harding
Graesser et al. — the closest analog of our farm, though divergence there is
a by-product rather than a design goal), emergent translation (Lee et al.),
and iterated learning's compression pressure (Kirby et al.), which we
implement as frequency-driven minting. Divergence between language-model
agents is now observed in the wild: Beltoft et al. (arXiv:2605.31170) report
emergent languages in populations of LM agents, from token efficiency to
oversight evasion — divergence observed, not farmed or priced — while Kong,
Lai, Piao & Evans (arXiv:2605.17193) find the opposite dynamic, robust
semantic collapse across multi-LLM systems despite lexical variation, so
divergence is not free to farm in LLM populations. Adjacent and pairwise by
construction: semantic channel equalization aligns the latent spaces of
independently trained communicating agents (Sana & Calvanese Strinati;
Hüttebräucker et al.), vec2vec translates between text-embedding spaces
without paired data (Jha et al.), and Levy et al. (AAAI 2025) decipher
emergent protocols by unsupervised machine translation without parallel data
— two-space alignment and translation systems, without ≥3-node loops or a
residual native to the representation algebra.

**Interaction-based ontology alignment repair.** Ontology alignment has long
repaired correspondences from communication failure: agents that argue over,
accept or refuse candidate correspondences (Laera et al. 2006), ontology
negotiation among heterogeneous agents (van Diggelen, Beun, Dignum, van Eijk
& Meyer, ANEMONE, *Applied Ontology* 2007), on-the-fly repair of structural
and lexical mismatches (Togia & McNeill 2013), alignment of experientially
grounded ontologies through language games (Anslow & Rovatsos 2015),
interaction-based repair with expansion and relaxation (Euzenat, IJCAI 2017)
and its dynamic-epistemic-logic formalisation of the Alignment Repair Game
(van den Berg, Atencia & Euzenat, AAMAS 2020), ontology negotiation that
limits logical violations (Jiménez-Ruiz, Payne, Solimando & Tamma, KR 2016), and, behind all of it, the language-game
tradition of Steels's *Talking Heads Experiment*. Those repair
correspondences between symbolic ontologies from communication failure; here
the maps are over sparse block codes, the witness is a third-party loop
invisible on the failing pair, and the repair is the inverse residual
installed on the listener edge.

**Distributed truth maintenance and multi-agent belief revision.** Doyle's
truth maintenance system (1979), its distributed form with justification
networks and the distinction between local and shared consistency
(Bridgeland & Huhns, AAAI 1990), and Dragoni's model of belief revision in a
multi-agent environment (1992), in which provenance is required to repair a
contradiction, are the ancestors of our trails and refusals. They keep
provenance for and revise *beliefs*; we calibrate *representations*.

**Evidence-gated belief revision (2026).** Preregistered Belief Revision
Contracts (arXiv:2604.15558) gate belief change on externally validated
evidence witnesses with a conservative fallback; *Replicating Belief, Not
Bits* (He & Yu, arXiv:2607.09748) replicates epistemic state across agentic systems with
ACCEPTED / REPAIRED / QUARANTINED / REJECTED / NEEDS_OPERATOR outcomes and
provenance-aware
partial-dependency repair. They gate belief updates; we gate the repair of a
translation edge on direct anchor evidence and a loop certificate.

**Layered agent-system evaluation (§11).** The nearest neighbours of §11's
factorial are Layer-Isolated Evaluation (Zhang, Wang & Lei,
arXiv:2606.11686) — one-layer-at-a-time regression injection, no crossing,
no authority layer, not preregistered — MAS-FIRE (arXiv:2602.19843), and the
lease and authorisation layers of CapLease (arXiv:2608.01710) and ScopeGate
(arXiv:2606.28679), scenario-evaluated rather than factorial. No
preregistered agent-system factorial crossing translation, grounding and
authority was found.

**Positioning.** The ingredients are individually established — VSA binding
and invertibility, sparse-block modular binding, multi-node cycle
consistency, holonomy as a representation diagnostic, repair of globally
inconsistent pairwise mappings in the synchronization literature — and
"pairwise consistency does not imply global consistency" is classical in map
synchronization; we do not claim it, and we do not claim the propositions.
The contribution is not cycle consistency, holonomy, ontology alignment, or
the general idea of refusing an unsupported repair; those have substantial
prior literatures. The contribution is an executable instance in which
independently evolved representational codebooks are calibrated without
imposing a common codebook; higher-order inconsistency is converted into a
local, constructive repair of the map itself; and the instrument's success
and refusal boundaries are measured under controlled semantic faults
(§7–§9, §11).
The claim, narrowly: to our knowledge this is the first construction in
which divergent sparse-block codebooks are calibrated across a population by
multi-agent loop residuals that remain native symbolic vectors and are
reused as the repair of the map itself; the nearest miss, Mishra's harmonic
residual, reuses a residual to gate abstention, not to repair a map. Bounded
by the companion survey's coverage and the 2026-09-05 pass; the survey names
its own collapse conditions (any VSA work composing bindings around a
≥3-node loop, any system reusing the cycle residual as the repair of the map
itself, or resonator-based missing-factor repair, would narrow it further).

## 3. The Substrate

Sparse block code: SDIM = 2^20 as K=64 blocks × B=16,384 slots; a codeword is a
K-tuple of slot indices; the deterministic mint (`fnv1a64` seed, `splitmix64`
draws) makes symbols *be* vectors — no stored codebook, atoms comparable across
runs and implementations. Binding is per-block addition mod B: commutative,
exactly invertible, and — the property everything downstream leans on —
**compositionally exact**: no noise accumulates around loops.

The expected number of matching blocks between unrelated atoms is K/B ≈ 0.004
(we use ≤2 of 64 blocks as the empirical floor throughout).

## 4. Translation Maps and Abelian Holonomy

**Maps.** A translation map A→B is itself a vector: one slot offset per block,
plus a per-word exceptions table of residual deltas (a `TranslationMap`). Maps
are *learned* from anchor pairs by per-block majority vote; whatever the vote
rejects lands, per word, in the exceptions table. Both halves serialize to SPO
triples: a learned map is walkable state, not a blob. The model's honest
metric is the exception rate — if exceptions carry the map, divergence was not
offset-shaped (we measure the response curve in §6.4). The vote also fixes the
instrument's second blind spot, besides one-triangle attribution (§7.2): a
quirk shared by a majority of a pair's anchors is voted into the offsets
themselves and surfaces as neither exception nor excess — consensus error
reads as calibration.

**Notation.** Write mₑ for edge e's per-block offset vector and eₑ,ₜ for its
exception residual on token t (zero when the token has no exception); every
sum below is per-block mod B. The map carries token t as

    M_e,t = m_e + e_e,t

Around a cycle C:

    H   = Σ_{e∈C} m_e            (the global defect — the register baseline)
    H_t = H + Σ_{e∈C} e_e,t      (the per-token loop)
    E_t = H_t − H = Σ_{e∈C} e_e,t   (the per-token excess)

§6.2's baseline is H, §7.2's abduction returns Eₜ, and the repair
precondition of §7.2's corollary reads directly off the last identity: the
excess is the sum of the loop's exception residuals, so installing −Eₜ on one
edge is the whole correction exactly when that edge's own term is zero.

**Holonomy.** Composition of maps is per-block addition; the holonomy of a loop
is the composed total. Because binding commutes, offset holonomy is *abelian*:
independent of base point and traversal order — the defect is the plain sum of
edge offsets. Three consequences:

1. It is not trivial: pairwise-consistent edges can still close to a nonzero
   sum (m_BA = −m_AB makes every 2-cycle flat while m_AB + m_BC + m_CA ≠ 0).
2. It is exact about the loop: the residual's nonzero blocks localize the loop
   disagreement and its values read it back with sign. Prior
   representation-holonomy work typically reduces the loop operator to scalar
   or spectral diagnostics (Sevetlidis & Pavlidis's deviation-from-identity
   statistic; Javidnia's holonomy distances); here the native residual is
   already a block-indexed symbolic object, inspected and reused directly.
   Exactness is about the cycle residual, not its
   cause: a triangle reports the sum of its edges' quirks, and which edge
   contributed what is underdetermined at a single loop (§7.2).
3. Its limit is stated, not hidden: exceptions keyed by unchanged tokens are
   still abelian. Genuine non-commutativity requires maps that *relabel*
   tokens (the second hop's lookup depending on the first hop's output); this
   is the unexplored seam (§12).
**What a 2-cycle can and cannot see** (measured, §6): round-trip defect catches
learned asymmetry (read back with sign, per block) and unmatched exceptions
(localized to the word; an architectural contrast with VSAIT, whose
consistency signal is a single global inversion objective — a difference of
signal shape, not a benchmark). It provably cannot catch a
pairwise-consistent triangle, and —
sharper — round-trip consistency *conceals* mistranslation: a map that carries
a word to the wrong place and back is flat.

**Severity is collision, not magnitude.** A sparse defect is a near-miss at
decode time: a code perturbed in 3 of 64 blocks still matches its referent in
61, and nearest-neighbour decoding resolves it correctly — a perturbation in k
blocks still decodes correctly whenever no other expected code shares more
than 64 − k blocks with the referent; random drift therefore lands in empty
space until the perturbation is nearly dense. Comprehension fails when a
drifted production lands on another word's expected code: conflation.
Detection (the loop) and severity (collision) are therefore independent axes;
a loop can flag a defect that does not yet matter, and §7.2 constructs the
ones that do.

## 5. The Genealogical Mint: Seed and Schism

The frozen shared seed codebook stays under its original deterministic
contract, byte-identical (the arc adds zero lines to the seed mint file; the
layered mint is a separate module above it).
A tribe's divergence is a *layer*: new words minted as compressions of
parent-stack expressions, each with (i) a fresh atomic code, deterministic in
(parent-stack fingerprint, tribe, epoch), and (ii) a recorded definitional
composite — ordinary SPO facts. One validation rule — components must resolve
strictly in the parent stack (no self-reference, no siblings, no shadowing) —
makes cycles impossible and grounding-to-seed total by construction. A schism
forks the stack; genealogy is a tree; `expand()` walks any tribal word down to
seed vocabulary.

Design consequence stated honestly: a compression's code carries no useful
similarity signal to its parts (fresh atomicity — expected overlap with its
own components sits at the K/B chance floor of §3), so an unknown word cannot
be half-understood — the recorded facts are the only route down (a redundant *bound* encoding,
added precisely because of this, is §7.3's subject). Layering handles vocabulary
GROWTH; DRIFT of shared words is the offset maps' domain. The two mechanisms
are complementary, and the two repair channels (§7) inherit the split.

## 6. Experiment I: Farmed Divergence

Three tribes over a shared seed (~30 words, ~40 composite templates in 2
topics). Two divergence mechanisms only: **topic-conditional drift** (a tribe's
working code for a seed word = seed atom ⊕ that topic's accumulated drift — the
register mechanism) and **frequency-driven compression** (recurring adjacent
pairs mint as new words; ties break on a per-tribe salt). Contact = adoption
(shared experience) + anchor exchange (both sides learn maps). All randomness
label-keyed splitmix64; every number below reproduces from a seed (seed 7
unless stated) and is asserted exactly in the pinned test record (§6.5's
counts in the scaling suite; Receipt B).

Metrics, defined. **growth_jaccard**: |shared (name, definition) pairs| /
|union| over two stacks' minted words. **nesting_disagreement**: among
same-named words minted by both tribes, the fraction whose definitions differ.
**surface_disagreement**: the same fraction for differing seed expansions.
**drift_blocks**: count of nonzero blocks in a learned map's offsets.
**exception_rate**: |exceptions| / |anchors| of a learned map. Two knob
configurations appear below and are always named: **config A** (compression
threshold 3, budget 2 — defaults) and **config B** (threshold 2, budget 1 —
the growth setting used for every §6.2–§6.3 and §7 number).

### 6.1 Contact-linguistics sanity
Two runs, reported separately (v0.1 wrongly conflated them). Config A,
isolation, 20 epochs: A↔B drift_blocks climb 4 → 45 of 64, non-strictly
monotone (the full series is pinned). Config B, 30 epochs — the same series
ends at 57 — shows the contact effect on vocabulary: per-pair growth_jaccard
0.071 / 0.143 / 0.182 isolated vs 0.318 / 0.513 / 0.311 with contact from
epoch 12. The best pair improves 0.18 → 0.51, but the best pair differs
between runs, so all three are reported. Divergence grows with isolation and
shrinks with contact.

### 6.2 The crux, farmed and generalized
Constructed first (the gate experiment): a tribe with a hidden register split S
meeting each neighbor in a different register yields all-flat 2-cycles and loop
defect = −S exactly, localized to S's blocks; control with S=0 is flat.
Then farmed: under a topic-sliced schedule (A↔B on topic 0, B↔C on topic 1),
the same separation arises with *no designated hidden variable*:

    loop = (dB0 − dB1) − (dC0 − dC1)

— the difference between two tribes' register splits. The constructed case is
the C-uniform special case. **Holonomy measures between-tribe disagreement
about register structure**, which independent drift generically produces
(equality of two independently accumulated register-split vectors is possible
but occupies a vanishingly small fraction of the modular state space; we do
not prove impossibility). The result is endogenous rather than spontaneous: the
simulator's drift is topic-conditional by design and the schedule slices
contact by topic — what is *not* injected is the loop defect itself, which
these local rules are sufficient to produce. Pinned over
seeds 1–32 (pairwise flat + loop dirty at every seed, defect blocks ranging
36–44; uniform-topic control flat at every seed), with the identity asserted
as exact equality against the tribes' actual drift state at every seed 1–32
(the all-seeds identity test, pinned — Receipt B; baselines 36 / 42 / 43
blocks at seeds 1, 7, 8).

### 6.3 The fractal signature
Nesting disagreement 0.19–0.24 with surface disagreement exactly 0.0: same
word name, same expansion to seed, different definition — the tribes compressed
the same surface in different orders ((x y) z vs x (y z)), driven only by
mint-order ties. Divergence of parse without divergence of surface. The
signature is present at all 32 seeds under config B (nesting disagreement up
to 0.40, surface disagreement exactly 0.0 throughout); under config A absent
at two of 32 seeds (pinned).

### 6.4 Kill-criterion response curve
Exception rate vs injected idiosyncrasy, config A, 10 epochs, **per pair**
(v0.1 quoted A↔B unqualified): at idiosyncrasy 0 / 0.3 / 0.6, A↔B reads
0.000 / 0.346 / 0.654, and 0.346154 equals A↔B's quirked register-union
fraction 9/26 exactly — an identity that holds at every seed 1–32 under both
configurations (pinned).The
other pairs are higher because their registers draw
more quirked words (B↔C 0.48 / 0.68, C↔A 0.50 / 0.85 at 0.3 / 0.6) — the
mechanism, not noise, and pinned. At zero idiosyncrasy every pair is 0.000:
register drift is fully vote-absorbed; idiosyncratic drift is fully
exception-carried. The offset model survives exactly the divergence it claims
to model.

### 6.5 Scaling the witness
Three agents are the minimal witness for the topological claim, not the
intended operating regime. A deliberately cheap N-agent harness
(every count below pinned; Receipt B)
separates the scaling question from the cognitive simulation: each agent
carries one private global drift, so learned edge offsets form an exact
gradient (asserted, not assumed — unanimous vote, zero exceptions) and every
cycle's baseline is flat; a quirk is a stale per-token exception installed on
one directed edge with its reverse map carrying the matching inverse, so
every 2-cycle stays flat — the quirked token's included — while every
fundamental cycle through that edge reports the quirk exactly, with
orientation sign. Detection runs over the fundamental cycle basis of a
spanning tree, one cycle per chord. At seed 7, 30-token vocabulary,
anchor_fraction 0.6:

| agents | edges | basis cycles | quirks injected | dirty cycles | detection |
|-------:|------:|-------------:|----------------:|-------------:|:----------|
|      3 |     3 |            1 |               1 |            1 | exact     |
|     10 |    20 |           11 |               5 |            7 | exact     |
|     30 |    60 |           31 |               5 |           13 | exact     |
|    100 |   200 |          101 |               5 |            9 | exact     |

Every injected quirk is detected in every basis cycle traversing its edge,
excess exact, clean cycles abducing nothing; an unpinned broader sweep of 48
configurations (seeds 1–16 × N ∈ {5, 10, 30}) holds without exception, and
the N = 100 row's exact detection holds at seeds 1–8 (dirty basis cycles
18 / 40 / 13 / 7 / 9 / 9 / 9 / 7; pinned per seed; Receipt B).
Observed wall time is approximately proportional to the number of basis
cycles at fixed vocabulary and graph construction — about 4 / 21 / 63 / 226
ms for 1 / 11 / 31 / 101 cycles (indicative, machine-local, not pinned):
the instrument stays cheap at population scale. One structural boundary stated
rather than hidden: an edge no basis cycle traverses is outside the basis's
witness entirely, so quirks are placed on covered edges only — coverage is
itself asserted, and witnessing an uncovered edge needs a richer basis, not
a better detector.

## 7. Experiment II: The Two Repair Channels

### 7.1 Growth channel — repair by genealogy descent
An unknown minted word is a total comprehension failure (fresh atomicity: best
overlap ≤2, decode returns nothing). Repair: rebuild the speaker's stack from
its exchanged genealogy facts over the shared seed, adopt bottom-up preserving
the speaker's parse, alias when the listener already holds the expansion under
any name (which makes repair idempotent for free), disambiguate rather than
shadow on name collision. On farmed divergence: comprehension 0.75 → 1.0 on
the n=4 test utterance — the single missed word repaired exactly, not a
statistic — with a 3-deep nest crossing with every level's definition intact. Every repair
returns a literal SPO trail. Missing facts raise a named refusal
(`MissingGenealogy`) — the entry point for §7.3's exact signature
factorisation, which recovers a definition the facts no longer supply.

### 7.2 Drift channel — the closed loop
Anchor exchange is subsampled (anchor_fraction 0.6 — you do not calibrate
every word with every partner). The comprehension-breaking quirk is
*injected* against this farmed background: ordinary sparse drift lands in
empty code space and is comprehension-benign (§4), so the severe case — a
collision-shaped production error — is planted deliberately, with the farm
supplying the register baseline and the anchor-sampling geometry it hides in
(an endogenous collision mechanism, e.g. compression pressure landing on an
occupied code, is future work). Tribe A's production quirk i_t on a word
outside the A↔B sample but inside C↔A is *invisible pairwise*: m_AB has no
exception, the round trip is flat, and B decodes A's t as u at overlap 64 —
confident misunderstanding, strictly worse than ignorance. The triangle names
it: per-token loop minus the global baseline = i_t exactly; zero for all other
words; zero-idiosyncrasy control abduces nothing over a 42-block-bent
baseline. The global alarm, meanwhile, saturates under farming (62 of 64
blocks by epoch 29 of the sliced run, pinned in CI): drift bends every block
long before any one word matters, so abduction is necessarily
per-token-minus-baseline, never a reading of the global defect. Repair =
install inverse(excess) on the edge the listener owns — evidence-free for the
quirked word by construction; comprehension
0.667 → 1.0 on the n=3 test utterance (the one mistranslated word repaired
exactly); post-repair abduce = {}.

Two boundary results:

- **Post-condition.** Under registers, repair returns the per-token loop to
  the register *baseline*, not to zero; "excess gone" (abduce = {}) is the
  correct acceptance, and literal flatness is the single-register special case.
- **The merger/swap boundary, as a theorem.** Maximal collision (i_t carries
  t's production exactly onto u's) is loop-repairable but not
  comprehension-repairable; an equally severe *swap* (t↔u) is fully
  recoverable: both abduced with exact excesses, both patched, no residual
  collision. These are the two boundary instances of:

  **Proposition 1 (standard; stated for this substrate) — the repairability
  boundary.** *Fix the token set T in play and
  a production map p: T → codes. A reception assignment (any per-token
  expected code — representable in the offsets+exceptions map class, since
  exceptions are unconstrained per token) achieves exact decode on T (with
  the decode floor at most K) iff p is injective on T.*

  *Proof.* If p is injective, set entry(t) = p(t) for each t ∈ T: a received
  p(t) matches its own entry in all K blocks and any other entry in fewer
  (codes distinct ⇒ they differ in ≥1 block), so the nearest neighbour is
  *unique* and decode returns t for every token — no tie is possible. If
  p(t) = p(u) with t ≠ u, the received codes are identical, so any
  deterministic decoder assigns both the same token and errs on at least one
  of them; in the implementation such ties resolve by token order, which is
  why the merger experiment's winner is the lexicographically first. ∎

  (The tie rule, measured — over every eligible quirk at seeds 1–32 and three
  anchor fractions (888 cases) the operator names the word, flattens the
  loop, and leaves exactly one of the pair understood, the first in token
  order, every time; the evidenced-edge refusal is drawn in all 70 cases
  where an abduced excess meets direct evidence (pinned).)

  Proposition 1 is standard — the definition of decodability under
  nearest-neighbour decode, with the tie case made explicit. The
  merger/swap boundary the experiments exhibit is a result of this
  instrument at that definition's edge, not a theorem about information
  loss; the instrument's contribution is stated once, in §2.

  **Corollary (the operator attains the bound on an evidence-free edge).**
  Let the patched edge carry no prior exception for the abduced token — the
  *missing-anchor condition*, which is what the farm produces: the quirked
  token lay outside that pair's anchor sample. By §4's identity Eₜ is the sum
  of the loop edges' exception residuals; with the patched edge's own term
  zero, the excess is exactly the gap between the listener's expectation and
  the partner's actual production, so installing its inverse sets
  entry(t) = p(t): exact decode whenever Proposition 1 permits it — in the
  merger case it is the bound that fails, not the operator. The content is
  thus not "some reception works" (trivial given injectivity) but that the
  community loop *constructs* that reception from measurements alone, filling
  an edge precisely where the pair had no direct evidence, without
  re-anchoring.

  Without the precondition the identity still dictates a flattening residual
  (e′ = e − Eₜ), but flat is not the goal: an existing exception is direct
  anchor evidence, one triangle cannot attribute fault (below), and forcing an
  evidenced edge to absorb the loop defect would buy coherence at the price
  of pairwise calibration — coherence is not truth (§10). The operator
  therefore *refuses*: `patch` on an evidenced edge raises a named error
  (`ConflictingEvidence`), `close_loop` withholds the token, records the
  withholding in the trail, and leaves the defect standing — the alarm keeps
  ringing until attribution across more loops (below) can say which edge is
  wrong. Pinned as a regression: an abduced token whose own edge holds direct
  evidence is withheld, its excess unchanged by the episode, while an
  evidence-free companion token repairs normally in the same call.

  So **repair restores exactly what production preserved** — on an
  evidence-free edge — is a result of this instrument in-model, not a
  slogan; the experiments exhibit its two extremes.
  Linguistically: true homophone merger needs context (a reasoning-layer
  resource, outside this model); systematic transposition needs calibration —
  the loop supplies the latter.
- **Attribution.** One triangle reports a sum; any single edge absorbing the
  negated excess closes the loop, so each agent patches the edge it owns —
  pragmatic, not forensic. Unique edge blame needs a cycle basis over more
  loops plus a corruption/sparsity prior, and that is precisely the regime of
  cycle-edge message passing: CEMP (Lerman & Shi, *Found. Comput. Math.*
  22:1665–1741, 2022; arXiv:1912.11347) uses cycle-consistency information to estimate per-edge
  corruption levels, with Singer (2011) the foundation and
  Gao–Brodzki–Mukherjee the principal-bundle formulation. Given the
  corollary's refusal rule, attribution is consequential rather than
  forensic — the prerequisite for safe automatic repair wherever direct
  evidence already exists — and §7.4 builds it for our exact algebra, with a
  provable boundary (Proposition 2); the noisy-measurement regime remains
  CEMP's, and future work. Outside the certified boundary Paper 3 (§11)
  classifies identifiability on the actual residual vector with an
  independent exhaustive oracle (no shared code with the
  attributor), because the support-only generic criterion is exact only
  under general position and the proposition note (Receipt A) exhibits the
  failures.

### 7.3 Growth repair under fading memory — exact signature factorisation (v0.5)

With trails wired into the agent's decaying memory (§10), the growth channel
acquires a failure mode of its own — this is not a third translation-repair
channel but the memory half of §7.1: a definition nobody walks fades away,
and descent needs the facts it walks. The substrate's
forgetting is explicit decay against rehearsal, and reading is use —
recollection reinforces what it reads (with an instrument setting that does
not, because a rehearsing probe cannot measure decay). Since a tribal code is
a fresh atom (§5), nothing recovers a faded definition from the code alone;
recovery needs a redundant *structured* encoding that a different use pattern
keeps alive. Each minted word therefore carries a **signature**: the
order-safe n-ary bound composite of its component codes (position-permuted
binding). The asymmetry that makes signatures outlive definitions is an
explicit use-conditioned rehearsal policy — a designed memory policy whose
consequence is then measured: *hearing* a word rehearses its identity — signature,
integrity row, owning layer — while its definition components are rehearsed
only by *descent*. Measured on the live substrate: definitions fade at the
step their accumulated rehearsal depth predicts (self-calibrated in-test)
while the heard word's signature survives.

Recovery is then *exact signature factorisation* in the block algebra — not a
resonator network but an exact search with a clean refusal boundary: unbind
the known permuted components from the signature and scan the parent-stack
vocabulary for the exact residual match. A single unrelated candidate matches
with probability ~B⁻⁶⁴ for a candidate drawn uniformly from Z_B^K;
family-wise, a scan over V candidates false-matches
at ~V·B⁻⁶⁴ and the two-missing-factor search at ~V²·B⁻⁶⁴ — astronomically
small either way. The recoverer refuses rather
than guesses — corruption, wrong arity, more than two missing components, and
*ambiguity* (multiple exact solutions) all return nothing. Nested recovery
assembles seed-ward, so a recovered word becomes vocabulary for recovering
the word defined over it. On success the definition is redeposited: repair
heals the memory it reads, and a second repair needs no resonance. Scope
stated plainly: exact recovery reaches arity ≤2 — which covers this
substrate's entire farmed corpus, since compression mints binary — and a
faded three-component hand-authored definition is where the published
sparse-block-code soft-resonator line would take over.

### 7.4 Multi-loop attribution — blame within a boundary (v0.7)

§7.2 left attribution underdetermined at one triangle and refused to repair
an evidenced edge. This section builds the instrument that lifts the refusal
— the exact-arithmetic specialization of the regime CEMP occupies under
noise (every quoted number pinned; Receipt B). CEMP *estimates*
per-edge corruption from noisy cycle measurements by reweighted message
passing; here every cycle measurement is exact, so attribution becomes
minimum-support recovery over the cycle space, with hard refusal in place of
estimation.

Fix a token. Each covered undirected edge carries an unknown residual x_e;
each measured fundamental cycle reports the exact signed sum Σ ±x_e over its
edges. Linear algebra alone can never blame an edge:

**Proposition 2 (standard; stated for this substrate) — the attribution
boundary.** *Consistent attributions form a
coset of the cut space — any two differ by a vector c with
c_e = p_i − p_j for node potentials p — and a nonzero cut vector has support
at least λ(G), the edge connectivity of the covered graph. Hence if the true
per-token corruption support s satisfies 2s < λ(G), the minimum-support
attribution is unique and equals the truth.*

*Proof.* The fundamental-cycle-basis matrix is [I | N] with N a network
matrix, hence totally unimodular, so every minor is 0 or ±1 and every nonzero
Smith invariant factor is 1. The kernel mod B is therefore exactly the
integer kernel reduced mod B — the integer cut lattice mod B — and no non-cut
vector annihilated by a power of 2 can appear: the kernel is exactly the cut
space.Partition the nodes by potential value: a nonzero cut
vector's support contains all edges crossing a nontrivial partition, of
which there are at least λ(G). Then for any alternative x′ = x + c with
c ≠ 0: |supp(x′)| ≥ |supp(c)| − |supp(x)| ≥ λ − s > s = |supp(x)|, so x is
the strict minimum. ∎

Proposition 2 is standard: bounded-distance decoding uniqueness for the
graph's cut code over Z_B^K. The localisation principle behind it — that a
cycle's inconsistency locates the corruption on its edges — is CEMP's
(Lerman & Shi 2022); its single-corruption form is stated starkly in
higher-order group synchronization (Duncan & Kileel 2026), and Cycle-Sync
(Li, Shi & Lerman 2025) shows cycle consistency alone suffices for exact
recovery; §2 says what this section adds to that literature and no more.

K₃ has λ = 2, and 2s < 2 forces s = 0: **a single triangle can attribute
nothing** — §7.2's underdetermination is the λ = 2 case. A single long cycle
is no better (λ = 2 again; measured: one quirk on an 8-agent ring returns
eight tied alternatives and no blame). Population size buys nothing without
connectivity.

The implementation is enumeration with refusal: candidate supports in
increasing size over covered edges (necessary-condition pruning), each
solved by ±1-pivot elimination across all 64 blocks simultaneously, verified
against *every* row. A unique minimum yields blame, exoneration, and a
walkable SPO trail; tied minima yield a named ambiguity and no blame;
exceeding the search cap raises a named refusal (`UnattributableExcess`).
Uniqueness is an instance fact the enumeration itself establishes; the
Proposition 2 certificate (2s < λ, with λ measured by Stoer–Wagner) is a
graph fact reported beside it — and the two come apart: three
well-separated quirks on a λ = 5 graph recover uniquely at s = 3 with no
certificate (2·3 ≥ 5). One sentence of epistemic scope: the certificate is
conditional on the sparsity model. Cycle measurements establish the
minimum-support explanation; they cannot independently establish that
reality chose the minimum-support member of the coset — Proposition 2's
guarantee begins from the *true* support s being small, and "certified"
never means more than that. (§9 sharpens the certificate from the global
λ(G) to the local λ(u,v) — which is decisive on emergent contact graphs,
where bridges make the global form vacuous — and states the general-s
sufficient condition as Proposition 3′.)

Measured (seed 7; circulant contact graphs with min degree = λ, gradient
register baseline, quirks as stale per-token exceptions on distinct tokens,
pairwise-flat preserved; counts pinned):

| agents | edges | λ | basis cycles | quirks | blame | certified | circle closed |
|-------:|------:|--:|-------------:|-------:|:------|:----------|:--------------|
|     12 |    30 | 5 |           19 |      2 | exact | yes       | yes           |
|     30 |    75 | 5 |           46 |      3 | exact | yes       | yes           |

(60 agents, 150 edges, 91 cycles: exact and certified in ~240 ms —
indicative, unpinned.) Three mechanisms surfaced by the experiments, each
pinned:

- **The certificate is per-token.** Each injected quirk lands on its own
  token, so per-token support is s = 1 and certification needs only λ ≥ 3;
  2·(total quirks) < λ would be the binding form only if the quirks shared a
  token. The shared-token case is tested directly: two *cancelling* quirks
  on one token — invisible in their shared cycle, visible elsewhere — are
  recovered exactly at s = 2, certified at λ = 5.
- **Clean cycles carry the blame.** In the 12-agent run the quirked edge
  lies in exactly one dirty basis cycle, yet the verdict is unique: the
  rival edges run through cycles that reported nothing, and blaming either
  would dirty a clean loop. Clean rows are constraints, not silence — this,
  not a chorus of dirty loops, is how more loops beat one.
- **The boundary bites from both sides.** Corrupt all λ edges at one agent —
  a λ-cut — and the truth is not merely uncertain, it is *not minimal*:
  minimum support returns s − 1 with λ tied alternatives, and the instrument
  refuses. Inside the boundary attribution is exact; outside it, sparsity
  itself misleads — which is why the certificate is kept beside the answer.

The circle then closes: `overrule` — the operation `ConflictingEvidence`
exists to demand — subtracts a uniquely-blamed residual from the evidenced
edge's exception, dropping the exception entirely when it was wholly stale,
after which every basis cycle reads clean for that token. `patch` still
refuses evidenced edges; overrule, with a unique verdict behind it, is the
only key. An edge no measured cycle traverses remains outside the
instrument's world — never blamed, never exonerated, and the harness refuses
to place a quirk there rather than let an unwitnessable case inflate the
score. Paper 3 carries this boundary to the assertion boundary and reports it
as a validity boundary rather than a success region (§12.4)
:
exact recovery inside, confident wrong commitment outside, abstention at
λ = 2 — each with its allocation stated.

## 8. Experiment III: The Price of Divergence (v0.8)

Claim 1 — divergence should be farmed, not fought — entered this paper as a
design proposition. This experiment prices it. A deterministic task economy
(every quoted number pinned; Receipt B) runs the *same* task schedule under
three regimes over the three-tribe world, under config B (compression
threshold 2, budget 1 — the economy's defaults; §6 defines the labels)
:
**monoculture** (divergence fought — no
minting, no short forms, full seed vocabulary on every wire),
**unfarmed** (divergence without instruments — minting, short forms, no
maps, no genealogy exchange, no repair), and **farmed** (the same
divergence plus the full §7 instrument stack, every use of it charged to
the ledger: anchor pairs, genealogy facts shipped, loop audits).

Each epoch delivers coordination tasks (speaker renders a meaning in its
current vocabulary; listener must reconstruct it exactly; ~0.4 cross-tribe;
Zipf-ish repetition so meanings recur). A success pays 1; a full token on
the wire costs w, a short form w/4, and instrument traffic is priced in the
same wire units. w — the cost of bandwidth relative to the value of
coordination — is the experiment's single dimensionless knob.

**Collisions are endogenous here.** A tribe adopts a short form for any
word above a usage threshold, hashed into a deliberately small namespace
(M = 64 slots), and adoption is blind to collision — the economy permits
homophony rather than preventing it (unlike natural language, this model
supplies no contextual disambiguation, so its homophones stay lethal). At seed 7 this produces ten collided slots
across the three tribes (14 shadowed words; the quotable one: a seed word
and a word minted *over it* land on one slot, and the minted one loses). A
collided form decodes to its lexicographically first owner — Proposition
1's tie rule — so tasks meaning the other word fail, in every truncating
regime, 99 times in the run; and the instruments correctly never repair
one (asserted per-task: no repair event ever names a merger casualty).
Production destroyed the distinction; the ledger now says what that costs.

**The curves are exactly linear, so the crossovers are exact.** No agent's
behaviour depends on w, so one simulation per regime prices every w:
E(w) = successes − w·wire, and each crossover is a ratio of measured
integers, not a fitted point. Seed 7, 12 epochs × 60 tasks (720 tasks):

| regime      | successes | wire tokens (weighted) | E(w=1/32) | E(w=1/2) | E(w=4)  |
|-------------|----------:|-----------------------:|----------:|---------:|--------:|
| monoculture |       720 |                2097.00 |    654.47 |  −328.50 | −7668.0 |
| unfarmed    |       411 |                 855.25 |    384.27 |   −16.63 | −3010.0 |
| farmed      |       567 |                1110.75 |    532.29 |    11.63 | −3876.0 |

Farmed overtakes monoculture above w = 153/986.25 ≈ **0.155**; unfarmed
overtakes farmed above w = 156/255.5 ≈ **0.611**. So instrumented
divergence wins exactly the window **0.155 < w < 0.611**: below it,
bandwidth is cheap enough that fighting divergence (long, unambiguous seed
forms) is optimal; above it, even the instruments' own traffic costs more
than the misunderstandings it prevents, and *war beats farming*. The
window is where the thesis lives, and it is a measured region, not a
slogan. Across seeds 1–16 the window is non-empty at every seed (pinned per
seed as exact fractions: lower edges 628/4311 ≈ 0.1457 to 474/1855 ≈ 0.2555,
upper edges 214/443 ≈ 0.4831 to 308/447 ≈ 0.6890) — and, stronger, the
sixteen windows overlap: max w_L = 474/1855 < min w_U = 214/443, so
**0.2556 < w < 0.4831 is a farming window common to every seed tried**;
under config A the window is open at every one of seeds 1–16 with a common
window 0.256 < w < 0.537 (pinned).
In time, at w = 0.25:
farmed opens the run *behind* monoculture (3.38 vs 19.0 cumulative after
epoch 0 — the anchor exchange is prepaid before any vocabulary has
compressed), overtakes at epoch 4, and finishes 289.31 vs 195.75 — the
instruments are an investment with a visible payback period. The window is a
property of horizons long enough to collect that payback: at the reference
schedule (60 tasks per epoch) it is closed at three and four epochs for
seeds 7 and 3 (w_L > w_U) and open at every horizon of five epochs or more
at every seed tried, widening with horizon (seed 7: 0.242 < w < 0.306 at
five epochs, 0.155 < w < 0.611 at twelve, 0.098 < w < 1.396 at
forty-eight). Pinned; Receipt B.

Where the energy actually goes, farmed vs unfarmed (the speaking side is
identical between them, so every difference is instrument): repairs =
48 descents, 37 on-demand anchor top-ups, 1 loop patch; overhead 255.5
wire units. The structural counts are 325 genealogy facts, 90 anchor
pairs, and 12 audits; **under the reference tariff, genealogy shipping is
64% of the instrument bill** — walkable meaning is the expensive half of
comprehension. Descent repair converts failures into
recurrent successes (pinned exemplar: a foreign minted word fails once,
is adopted by paid descent, and succeeds on all 11 recurrences; unfarmed
fails all 12), but it never converges to zero — minting never stops, so
growth repair is a recurring bill, not a one-off onboarding cost.

**Tariff sensitivity, analytically.** Because behaviour is w-independent
and the two divergent regimes speak identically, the window's dependence on
the tariff itself is closed-form in the pinned counts. Let q be the
short-token price (reference ¼) and I the total instrument bill in
full-token units (reference 255.5). Then W_U = 600 + 1021q,
W_F = W_U + I, W_M = 2097, so the crossovers are
w_L = 153/(1497 − 1021q − I) and w_U = 156/I, and a non-empty farming
window exists iff

    I < (52/103)·(1497 − 1021q)

At q = ¼ the ceiling is 64571/103 ≈ 626.90: **the entire instrument bill
can rise ~2.45× before the window disappears**. Holding the bill fixed,
the short-token price can rise to q < 103055/106184 ≈ 0.97; holding
anchors and audits at reference prices, the most debatable single tariff —
the genealogy fact at ½ — can rise to ≈ 1.64 full-token units. The
reference window is not a knife-edge consequence of the chosen prices
(bounds pinned as exact fractions).

**The behavioural knobs, swept.** Namespace pressure M and cross-tribe task
frequency are the two knobs the economy's agents actually feel; both were
swept (every edge pinned as an exact fraction; Receipt B). **The window is open in 19 of 20 configurations**
over M ∈ {16, 32, 64, 128, 256} × cross-fraction ∈ {0.2, 0.4, 0.6, 0.8} at
seed 7, and at every one of seeds 1–16 in both harsh corners (M = 16 with
cross = 0.8; M = 256 with cross = 0.2): 32 of 32 open. The trends are
monotone and mechanistic. The upper edge rises with cross-tribe frequency —
above w = 1 at cross = 0.8 for every M ≥ 32: when most tasks cross a border,
instruments priced above a full token still pay — and the lower edge falls
with namespace size, since fewer collisions make entry cheaper. The
reference configuration (M = 64, cross = 0.4) sits inside the open region,
not on its boundary; its cell is the §8 window itself.

| M \ cross | 0.2 | 0.4 | 0.6 | 0.8 |
|---|---|---|---|---|
| 16 | **closed** (0.287 > 0.200) | 0.313–0.411 | 0.322–0.706 | 0.327–0.923 |
| 32 | 0.206–0.247 | 0.231–0.509 | 0.240–0.869 | 0.244–1.144 |
| 64 | 0.130–0.276 | 0.155–0.611 | 0.162–1.010 | 0.166–1.367 |
| 128 | 0.104–0.280 | 0.131–0.628 | 0.139–1.041 | 0.144–1.415 |
| 256 | 0.092–0.283 | 0.121–0.627 | 0.129–1.044 | 0.134–1.424 |

**The one closure is a boundary, not a tuning artefact, and it is kept.** At
M = 16 with cross = 0.2 — maximal homophony with minimal cross-tribe
coordination — the lower edge (0.287) sits above the upper (0.200), so
farming never wins. The inversion is intelligible. With sixteen short-form
slots, collisions are everywhere, and monoculture's unambiguous long forms
earn their bandwidth at any price the instruments could match; with a fifth
of tasks crossing a border, the instruments' subject matter is rare, and
their bill is paid on traffic that mostly never needed them. Nineteen open
windows plus one inversion that says why is stronger evidence than twenty
open windows would be: it locates the thesis's edge, where homophony is
maximal and coordination minimal. The closed cell's full regime map makes
"never" exhaustive: its three pairwise crossings are 1172/4087 ≈ 0.287
(farmed over monoculture, above), 1/5 (farmed over unfarmed, below) and
337/1241.75 ≈ 0.271 (unfarmed over monoculture, above), so monoculture is
optimal below w ≈ 0.271 and war above it, and farming is the best regime at
no price at all.

Three findings against the story, kept:
- **The loop instrument moves loss rather than erasing it — Proposition 1
  priced in energy.** The run's one (injected, at a documented rate)
  collision-shaped production quirk merges two of a speaker's words toward
  one partner. The audit catches it and patches the listener's own edge —
  after which the *quirked* word is understood and its collision partner
  becomes the casualty: farmed shows 6 misdecodes to unfarmed's 3. Repair
  restored exactly what production preserved, and nothing more; the ledger
  now exhibits the boundary as a cost, not just a theorem.
- **Calibration can poison the calibrator.** The quirked speaker's own
  reverse map is learned from its own corrupted production, so it loses
  the ability to *hear* the merged word from others — an emergent
  consequence of symmetric map learning, not an injection.
- **Third, and the sharpest: the loop channel's marginal value in this
  economy is at most zero.** Run with genealogy exchange, descent repair and
  anchor top-ups but *no* triangle audits (the audits-off regime, E1),
  the ledger loses exactly the audits' 3.0 wire units and the success count
  changes at three of sixteen seeds (+2, −1, −1); the farming window is
  unchanged to two decimals at every seed. With register drift set to zero
  the audits have almost nothing to find, so the window is a
  genealogy-and-anchor result and the loop instrument is carried by §6–§7,
  not by the ledger. Pricing it where it has work needs topic-conditional
  production and per-contact re-anchoring in the economy (§12).
  Pinned; Receipt B.

**The N-tribe economy, preregistered.**
The loop channel earned no positive marginal value in an N-tribe economy
with drift on (preregistered at df37a52 — this and the commit identities
that follow are the internal record's, listed in the artefact manifest;
development criterion not met;
confirmed on sixteen untouched seed blocks: ΔE(farmed − genealogy-only)
negative in 20 of 20 eligible cells and in every cell of both grids;
the preregistration and confirmation record, Receipt D; validated manifests,
development and confirmation accounts kept separate). What was found
instead: random sparse drift rarely breaks comprehension (24 qualifying
trajectories in 2,304 cells, in 3 of 32 seed blocks, all at the widest
drift); recurring re-anchoring in one register manufactures cross-register
failure (maps relearned every epoch in the contact register and applied in
the other register manufactured 3,016 and 3,151 failures — about 150× what
raw drift produced — and the loop repaired 9 and 2 of them; under this
cadence no instrumented arm beat forced uniformity at any tested price in
any cell); attribution outside its boundary is confidently wrong (unique in
~15 % of cases; of those, truth-correct in 12–13 % — the endogenous
corruption support lies far outside Proposition 2's bound, as the λ-cut
converse predicts); genealogy carries the farming economy (where any window
is open, farmed − genealogy-only = 0: the value is definition shipping and
descent repair). The limit: no collision-shaped corruption inside the
identifiability boundary was presented, so E7's regime stays reserved — the
result narrows where the instrument is worth its cost; it does not show loop
repair inert in principle. Paper 3's post-repair horizon reproduced the
limited behavioural visibility: a fifth of entity-bearing tasks refused at
decode from the generator's own unanchored divergence (refusal-dominated in
every stratum), the joint repair contrast was unobservable in every joint
cell because I repair removes the routed decode the contrast needs, and
horizon-wide target-correctness contrasts were within 0.02 — reported as
observability limits, never as zero effects (§11.5).
The allocation of burden: *genealogy preserves meaning through growth;
recurring re-anchoring in one register is a dangerous intervention; holonomy
diagnoses relational inconsistency; attribution requires its stated
topology; repair is permitted only after identification.*

Modelling choices, stated: register drift is set to zero (drift is §6's
subject; the ledger isolates vocabulary divergence, so cross-tribe seed
reception is exact in every regime); monoculture's enforcement is unpriced
— deliberately favourable to the regime the thesis argues against; one
ledger for the whole population; anchor exchange is charged both in bulk
at first contact and on demand when a short form proves illegible; merger
failures are classified before legibility, so no top-up is charged for a
resolution that cannot help.

## 9. Experiment IV: Emergent Geography (v1.0)

Every contact structure so far was authored — the farm's schedule, the
circulant graphs of §6.5 and §7.4. This experiment asks what the
instruments meet when tribes and their contact structure *emerge*. The
world (every quoted number pinned; Receipt B) is a deterministic
reimplementation of the
rule set of *Tribal Life*, an interactive cellular-automaton demonstration
of prefix tribalism by one of this note's authors: agents carry bit-string
prefixes — shared bits are "us", the first disagreement a border — walk
toward longer prefix matches so like clumps with like, and reproduction
under crowding appends a bit, so schism is hereditary; rare mutations flip
bits. Simplifications from the demo are documented in-module; rules are
otherwise unchanged. At seed 7 (24×24 torus, 64 founders, 120 epochs) the
population settles at 1,489 agents in six prefix branches, and clustering
is measured, not asserted: mean shared-prefix affinity 1.9963 among
contact-graph neighbours against 1.0581 population-wide. The contact
window yields a largest component of 214 agents, 353 edges, 140 basis
cycles.

**The border hypothesis, refuted.** We expected tribal borders to be where
attribution dies — thin connectivity between clumps. Planting a single
quirk on each cross-tribe edge and a matched interior sample and running
§7.4's attribution verbatim: border edges attribute *better* (73% unique)
than interior ones (54%). The structural reason: sustained cross-tribe
adjacency only survives where two tribes are pressed together, and a
contested interface is dense (border edges: mean λ(u,v) 4.68, mean minimum
endpoint degree 4.92; interior: 2.97 and 3.37 — pinned, Receipt B); the thin
structure lives at a tribe's
*periphery* — a parent and child drifting off a clump — which is, by
identity, interior. "Border" is about labels; "thin" is about degree; this
geography puts them in different places, and the direction is not even
seed-stable (seed 3 flips it). Locale is not the deciding variable.

**What decides is local connectivity — exactly.** Cross-tabbing every
covered edge by the *local* edge connectivity λ(u,v) of its endpoints:
λ = 2 edges are ambiguous 23 of 23 times; λ ≥ 3 edges are unique 80 of 80;
bridges (λ = 1) are exactly the uncovered edges. Zero exceptions, and zero
again at seeds 1, 3, and 11, and zero across torus sizes 16–32 and founder
counts 32–128 (seventeen board configurations, 3,565 covered edges;
pinned). This is Proposition 2 sharpened from the
global to the local form:

**Proposition 3 (standard; stated for this substrate) — the local
attribution boundary, single corruption.** *Let
edge e = (u,v) be covered (hence λ(u,v) ≥ 2) and carry the only corrupted
residual (s = 1).
The minimum-support attribution is unique iff λ(u,v) ≥ 3. At λ(u,v) = 2,
each 2-cut {e, f} through e yields a support-1 alternative on f (choose
the cut vector's value to cancel x_e), so the truth ties. (λ(u,v) ≥ 2 is
implied by the premise: a bridge lies on no cycle, so it is uncovered and
outside the instrument's world per §7.4; the iff therefore ranges over
λ(u,v) ∈ {2, 3, …}.)*

*Proof.* An alternative differing from the truth on e is truth plus a cut
vector c nonzero on e; c's support contains a u–v edge cut, so
|supp(c)| ≥ λ(u,v) and the alternative has support ≥ λ(u,v) − 1. This
exceeds 1 iff λ(u,v) ≥ 3. The λ = 2 construction above realizes the tie,
and every observed ambiguity is of exactly that shape (2–8 tied
single-edge alternatives, always containing the planted edge). ∎

Proposition 3 is standard — Proposition 2's local form, and at s = 1 the
statement the synchronization literature makes starkly: one corrupted
element, and the cycle's inconsistency gives that element's corruption
(CEMP, Lerman & Shi 2022; arXiv:2505.21932; Li, Shi & Lerman 2025 — §2).
The result of this section is not the proposition but that the emergent
graph realises the local boundary with zero exceptions where the global
certificate certifies nothing, and that the instrument abstains on the
λ = 2 side of it.

The same cut argument gives the general-s sufficient condition:

**Proposition 3′ (standard; stated for this substrate) — the general-s
local sufficiency condition.** *Call δ(U) a 2-sided cut for any vertex
subset U with both U and V∖U nonempty (the shores need not be connected).
Let the truth x have support S, |S| = s, and let every 2-sided cut δ(U) of
the covered graph that meets S contain strictly more non-truth edges than
truth edges: |δ(U) ∖ S| > |δ(U) ∩ S| whenever δ(U) ∩ S ≠ ∅. Then the
minimum-support attribution is unique and equals the truth. At s = 1 the
hypothesis is λ(u,v) ≥ 3, so Proposition 3's forward direction is the case
s = 1.*

*Proof.* Let x′ = x + c, c = grad p ≠ 0, and let P be the partition of the
nodes into p-classes; δ(P) = supp(c) is the set of edges between distinct
classes. On an edge e ∉ δ(P), x′_e = x_e. On e ∈ δ(P) ∖ S, x′_e = c_e ≠ 0. On
e ∈ δ(P) ∩ S, x′_e = x_e + c_e, which may vanish; call the set of such
cancelled edges T′. Hence |supp x′| = (s − |T′|) + |δ(P) ∖ S|. Each edge of
δ(P) lies in δ(V_i) for exactly two classes V_i. If some class cut meets S,
sum the hypothesis over those classes (strict) and the trivial bound
|δ(V_i) ∖ S| ≥ 0 = |δ(V_i) ∩ S| over the rest: every crossing edge is
counted twice, so 2|δ(P) ∖ S| > 2|δ(P) ∩ S| ≥ 2|T′|. If no class cut meets
S, then δ(P) ∩ S = ∅ and T′ = ∅, and since c ≠ 0 forces δ(P) ≠ ∅ we have
|δ(P) ∖ S| = |δ(P)| ≥ 1 > 0 = |T′| — the strictness comes from c ≠ 0, not
from the cut hypothesis. In both cases |δ(P) ∖ S| > |T′|, so |supp x′| > s.
Every alternative is strictly larger than the truth. ∎

Its converse is false for s ≥ 2 — a cut can violate the hypothesis and still
be unable to cancel two corruptions at once, so uniqueness survives — and the
exact boundary for residuals in general position is a forest condition on
the cut's quotient graph; both are stated, exhibited and checked against the
solver in §12.4 and the proposition note (Receipt A).

The sharpening is not a nicety — on this emergent graph it is the whole
result: the covered subgraph decomposes into seven 2-edge-connected blocks
joined by bridges, so the *global* λ(G) ≤ 1 and Proposition 2's published
certificate certifies nothing, while the local form certifies 80 of 103
covered edges. Emergent geography is exactly where the global-to-local
refinement earns its keep.

**The crux under an emergent schedule.** Mapping the three largest tribes
to A/B/C and compiling their measured contact into the farm's schedule DSL
(60 windowed rules; pairs meet when cross-tribe adjacency clears a
threshold, topic = the grid half holding the contact centroid) reproduces
§6.2's separation: all three 2-cycles flat, loop dirty at 64 defect
blocks. The emergent schedule is *not* cleanly sliced — every pair meets
on both topics as its interface migrates — and what bends the loop is
which register each pair occupied *last* (AB and BC ended in register 1,
CA in register 0). The control isolates the cause: the same fragmented
windows with every topic flattened to one register close perfectly flat
(0 defect blocks). The separation needs the register *assignment*, not
schedule fragmentation — geography supplies exactly the asymmetry §6.2
previously had to author.

One honest note from tuning: the CA's movement rule and a scarce-forage
economy pull against each other — kin-seeking agents re-tread stripped
ground, and every hungry configuration went extinct. The stable identity
(regeneration = crowding cap × living cost) is documented in-module; the
rules themselves were not changed.

## 10. What This Buys an Agent Architecture

As of v0.5 the integration this section previously declared not-done is done:
translation maps, genealogy stacks, and repair trails deposit into the
agent's memory roll as ordinary facts through the substrate's public API,
kept alive by rehearsal and lost to decay like everything else the agent
remembers. Sparse serialization cannot distinguish a zero from a decayed row,
so every deposit carries integrity rows and a shortfall surfaces as a loud
refusal, never a silently shortened map or definition — and a genealogy that
fades because nobody walks it produces exactly the missing-facts regime of
§7.3, with nobody deleting anything. What the experiments establish for an
architecture: calibration knowledge is naturally distributed (C knew A's
quirk; the loop routed it to B without B ever re-anchoring with A), every
detection and repair emits a walkable trail rather than an opaque update, and
what a mind keeps understanding it keeps — comprehension itself is the
rehearsal that preserves the machinery of comprehension.

One separation must never collapse: **holonomy measures coherence of
translation, not truth.** A perfectly flat triangle can be three agents all
wrong about the world; conversely, agents individually well-grounded in the
same reality can hold broken translation relationships and ring a dirty loop.
Flatness is a property of the relationship layer. An architecture should read
it as exactly that — alongside, never instead of, whatever grounds the seed
vocabulary in the world. That composite experiment has been run (Paper 3,
preregistered at f8b1f2d and frozen at e39916e; §11): a seed vocabulary whose
concepts have canonical world entities under an authoritative works ledger;
one staged assertion — decode → concept by genealogy → entity by active
evidence → `assert(op, s, actor)` — over which a translation swap on the hop
used, a rebound evidence revision on the routed concept, and a lease
revocation over a fixed authority universe were installed independently as a
2 × 2 × 2, with G and A inspected by construction and only I inferred. In
2,104 admitted held-out cells the submitted tuple went wrong exactly when the
construction said it would (mismatch iff G ∨ I, contained iff mismatch ∧ A):
containment is a construction identity, not a capability. No layer
impersonated another: the ledger refused a revoked lease on a perfectly
decoded, perfectly grounded tuple, and repaired evidence did not repair a
swapped decode. What the composite adds beyond this section's separation
principle is the assertion-boundary measurement of §7.4's attribution
boundary and of repair without displacement (Paper 3 result card, §11.7;
§12.4–12.5).

## 11. Experiment V: One Assertion, Three Layers

### 11.1 The question and the design

§10's separation principle — holonomy measures coherence of translation, not
truth — carried a composite experiment as future work: a seed vocabulary that
is itself world-grounded, so that a tribal token expands through its
genealogy to seed concepts and onward to authoritative referents. Paper 3 ran
it, preregistered. The question, as frozen: on one staged assertion over a
shared world — decode → concept by genealogy → entity by active evidence →
`assert(op, s, actor)` — when a translation swap, a rebound evidence revision
and a lease revocation are installed independently over a fixed authority
universe, how often does the submitted tuple go wrong, how often does loop
attribution hit its proved boundary and stay silent outside it, and how often
does eligible repair restore the intended act without moving the fault?

**The three layers.** Genealogy determines which *concept* a token means;
active evidence determines which *world entity* currently instantiates that
concept; the ledger determines whether the submitted operation on that entity
is authorised. Their states are disjoint; they meet only on the staged path.
One fault per layer, installed independently as a 2 × 2 × 2: **I**, a
translation swap on the hop used — Proposition 1's swap, written as two
coupled exception entries on the canonical map of the edge, with the derived
inverse and both receptions following; **G**, a rebound evidence revision on
the routed concept; **A**, a lease revocation over a fixed authority
universe, a between-cell factor. G and A are inspected by construction —
their states are read directly and serve as admission gates, never as
numerators — and only I is inferred, by §7.4's attribution run against the
constructed truth. Containment (a wrong tuple refused by the ledger) is a
construction-verified institutional guarantee, not an estimated capability;
the experiment is an estimation study, and no observed rate licenses a
categorical capability claim. Its nearest neighbours — layer-isolated
regression injection, and scenario-evaluated lease and authorisation layers
— are placed in §2; no preregistered agent-system factorial crossing
translation, grounding and authority was found.

**Strata and arms.** N ∈ {3, 6} × contact graph ∈ {authored circulant,
CA-grown (§9)} × role ∈ {observe-only, observe+alter}: eight strata, each
with the eight cells of the factorial, every seed running the full cross. A
cell with exactly one repair-eligible fault runs two arms from the same
pre-weld state, *none* and *weld*; a cell with two runs four — *none*,
*G-only*, *I-only*, *both* — with the partial arms as contrast arms and the
maximal arm the permitted one. The attribution diagnostic keeps §7.4's
solver and its s ≤ 4 search cap (`K_MAX = 4`); a verdict is *certified* iff
it is unique and Proposition 3′'s sufficiency criterion holds on its own
returned support. Instances whose true support exceeds the cap are admitted,
labelled search-outside, and reported — the cap is an instrument limit, not
an admission boundary. Outside the certified boundary, identifiability is
classified on the actual residual vector by an independent exhaustive oracle
sharing no code with the attributor, not by the attributor.

**Preregistration and freezes.** Design frozen at `f8b1f2d` (v0.19), with
two amendments, each ruled before the data it concerns. Amendment 1: the
frozen single-entry translation fault proved unconstructible — a single map
entry moves the clerk's expectation away from the speaker's unchanged
production and every I = 1 cell voids at the landing gate as a decode
refusal, never a landing — and was replaced by Proposition 1's swap; the
merger is never a comparator or an arm (§12.6). Amendment 2: the calibration
validator's bookkeeping missed that history row 0 carries an empty window;
corrected without changing generator, detector, any diagnostic, threshold or
outcome definition, and the validation range that diagnosed the defect was
retired. Implementation signature 2 at `daea9a5` (blob hashes and verbatim
quotations of every named function; the preregistration record, Receipt C).
Calibration freeze (Receipt C): fitting seeds
1001–1500, validation 2601–3100, farm references 2001–2100. Development
seeds 101–116 run once and their account written
(the development account, Receipt C; sixteen seeds, below the floor
everywhere, so every quantity there is descriptive); held-out seeds 117–152
(36 seeds) run once on the compute host from `daea9a5`, after the
development account
and with the design, the signature and the calibration freeze unchanged.
Validated manifest: 288 / 288 strata attributed to one producer, generative
blobs identical, no missing, extra, unattributed or doubly-attributed cell,
no problems. Smoke seeds 9001–9002 are feasibility pilots outside every
allocation; seeds 117–152 are never reused.

**Inference.** Seed is the inference unit: within-seed cells are repeated
observations of the seed, never independent units; strata are reported
separately and never pooled into a ruling. Bounds are a seed bootstrap
(10,000 resamples, seed 20260904) or, for seed-level binary events, exact
one-sided 95 % Clopper–Pearson (0 / 36 → 8.0 %). **A quantity with fewer
than 25 contributing seeds is printed as *unsupported at this allocation*
with its count and no bound**, exactly as preregistered — the floor is the
precision rule, fixed before any seed ran, and missing it is a report, not
an instruction to sample until a bound appears. The hierarchy this section
keeps throughout, in the account's own words: *unsupported at this
allocation*; *supported*; *observed but not precision-supported*; *not
established*; *structurally unobservable*.

### 11.2 The headline, stated first

**The primary estimand is unsupported at this allocation.** `M_I` on
certified-identifiable, search-covered I-a instances (N = 6 strata only)
had 18, 15, 23 and 21 contributing seeds in the four N = 6 strata
(circulant observe-only / observe+alter, CA observe-only / observe+alter)
against the floor of 25. Its point value is 1.0 in every stratum — every
certified, search-covered verdict recovered the complete constructed
support and residual — and no bound is issued. The allocation was thinned
by construction failure (4–6 seeds per N = 6 stratum failing the
learnability band) and by the target token's endogenous background
placing 7–11 seeds per stratum outside the diagnostic's search bound.
This is the outcome the design pre-committed to printing without
apology; it is not a failure of the diagnostic, which never produced a
wrong certified verdict inside its boundary.

### 11.3 What the allocation supports (≥ 25 contributing seeds)

| quantity | N3 (four strata) | N6 circ. obs-only | N6 circ. obs+alter | N6 CA obs-only | N6 CA obs+alter |
|---|---|---|---|---|---|
| seeds constructed / 36 | 35 | 30 | 30 | 31 | 32 |
| construction-failure seed event (CP upper) | 1 / 36 (0.125) | 6 / 36 (0.303) | 6 / 36 (0.303) | 5 / 36 (0.270) | 4 / 36 (0.237) |
| VOID cells among constructed | 0 | 0 | 0 | 0 | 0 |
| **no seed exhibited *moved*** | 0 / 36 → **≤ 8.0 %** | 0 / 36 → ≤ 8.0 % | 0 / 36 → ≤ 8.0 % | 0 / 36 → ≤ 8.0 % | 0 / 36 → ≤ 8.0 % |
| `R_I` on non-identifiable, covered (N3: every verdict ambiguous at λ = 2) | **1.00 [1.00, 1.00]** (35) | unsupported (3) | unsupported (3) | unsupported (2) | unsupported (1) |
| `W_I` on non-identifiable, covered | **0.00 [0.00, 0.00]** (35) | — | — | — | — |
| certified-verdict share of I-a verdicts | 0.00 (35) | 0.67 [0.50, 0.83] (30) | 0.60 [0.43, 0.77] (30) | 0.90 [0.77, 1.00] (31) | 0.81 [0.66, 0.94] (32) |
| localisation (support contains e) | 0.00 (35) | 0.90 [0.77, 1.00] | 0.87 [0.73, 0.97] | 0.94 [0.84, 1.00] | 0.91 [0.78, 1.00] |
| composite, cell 010 / 011 | 1.00 [1.00, 1.00] | 0.77 [0.60, 0.90] | 0.67 [0.50, 0.83] | 0.81 [0.65, 0.94] | 0.75 [0.59, 0.88] |
| composite, cell 100 / 101 | 1.00 [1.00, 1.00] | 1.00 [1.00, 1.00] | 1.00 | 1.00 | 1.00 |
| composite, cell 110 / 111 | **0.00 [0.00, 0.00]** | 0.50 [0.33, 0.67] | 0.43 [0.27, 0.60] | 0.61 [0.45, 0.77] | 0.59 [0.41, 0.75] |
| composite, stratum | 0.667 | 0.756 [0.656, 0.844] | 0.700 [0.589, 0.800] | 0.806 [0.710, 0.893] | 0.781 [0.677, 0.875] |
| refusal rate on scored horizon rows | 0.17–0.22 | 0.134 [0.117, 0.152] | 0.180 [0.163, 0.197] | 0.136 [0.120, 0.154] | 0.182 [0.166, 0.198] |
| adequacy (map class): mean seed median, one-sided upper | 0.251 / 0.314 / 0.248 / 0.316; upper ≤ 0.328 | 0.214, upper 0.224 | 0.273, upper 0.284 | 0.216, upper 0.227 | 0.276, upper 0.286 |

Pooled composite by cell vector, vectors named, 263 admitted cells per
vector over 36 seeds: 010 / 011 **0.889 [0.833, 0.939]**; 100 / 101
**1.000**; 110 / 111 **0.264 [0.198, 0.338]**.

**Adequacy ruling: *adequacy established* in all eight strata** (one-sided
95 % upper bound ≤ 0.35 everywhere; calibration valid; contributing 30–35),
every stratum annotated **low-background / trivially adequate** (every
estimate below ρ_0.2 = 0.357). Under the preregistered adequacy ruling every
`M_I` supports only claims scoped to the recorded baseline-support class;
the certified instances are baseline-clear in 18 / 18, 15 / 15, 22 / 23 and
20 / 21 seeds, so **attribution under endogenous token-specific background
is not established** — the primary result is a planted-only boundary
result.

### 11.4 Repair and restoration

Every eligible repair closed and no repair moved the inconsistency:
G by re-observation in every G = 1 cell (weld, G-only and both arms; 140
per N = 3 stratum, 76–90 per N = 6 stratum in the weld arm), I by the
atomic two-token overrule in every conjunctively eligible cell (N = 6:
30–48 per stratum in each of weld, I-only and both; never at N = 3, where
no verdict is certified), the both arm commuting in every joint cell, and
the complete lease state byte-identical across every arm. Restoration on
the maximal arm: G-only cells always; I-only cells wherever I was
eligible; joint cells only where both faults were eligible — hence the
joint-cell composite of 0.43–0.61 at N = 6 and 0 at N = 3 ("replay
restored never; G fault repaired, I standing"). Repair cost 0.5 (I) / 2.5
(G) / 3.0 (both) wire per arm, booked as itemised lines.

### 11.5 The horizon: what could and could not be observed

Forced faulted-concept rows: candidates were a single token in every
cell (shortfall 3 of 4), so paired exposure is 1 / 4 at most. Weld − none
and G-only − none: exposed 1 / 4 in every G-eligible cell, the
identifiability condition met on every exposed row (`s` differs between
arms), target-correctness effect +1 per exposed row at I = 0 and 0 at
I = 1 (the repaired concept is the routed one, not the uttered one).
**both − I-only: 0 / 4 in every joint cell — unobservable, never zero**:
after I repair the token no longer decodes to `c_d`. Horizon-wide
target-correctness contrasts are 0.004–0.021 with bounds, and 10–30 of
each stratum's contrast cells are unobservable on opportunities
(G-opportunity and I-opportunity counts of 0–2 per arm). The seed-level
decode-refusal event is at its ceiling (30–35 of 36 seeds); every stratum
is **refusal-dominated** (> 5 %), which records the limited behavioural
visibility of the horizon rather than a defect.

### 11.6 The claim-relevance table, settled

| preregistered claim | outcome |
|---|---|
| per-stratum `M_I` with a bound | **unsupported at this allocation** in all four N = 6 strata (15–23 contributing) |
| "no seed exhibited *moved*, ≤ 8.0 %" | **supported**, 0 / 36 in every stratum |
| "no seed exhibited *moved*, ≤ 5 %" | unsupported at this allocation (needs 0 / 59) |
| certified vs uncertified `M_I` difference | not reportable: 1–2 uncertified seeds per stratum |
| adequacy of the map class | **established** in all eight strata, low-background annotation everywhere |
| `R_I` / `W_I` at λ = 2 | **supported**: 1.00 / 0.00 with degenerate bounds in every N = 3 stratum |
| composite by cell vector | supported at N = 6 (30–32 seeds) and N = 3 (35) |

### 11.7 The result card

**Question.** On one staged assertion over a shared world — decode →
concept → entity → `assert(op, s, actor)` — when a translation swap, a
rebound evidence revision and a lease revocation are installed
independently over a fixed authority universe, how often does the
submitted tuple go wrong, how often does loop attribution hit its proved
boundary and stay silent outside it, and how often does eligible repair
restore the intended act without moving the fault?

**Answer, as measured.** The submitted tuple went wrong exactly when the
construction said it would (mismatch iff G ∨ I, contained iff mismatch ∧
A) in every one of 2,104 admitted cells — containment held as the gate it
is. Inside the proved boundary the diagnostic was never wrong (1.0 on
every certified, search-covered instance) but the allocation cannot bound
that rate. Outside the boundary — at λ = 2, and where the target carried
background beyond the search bound — it refused in 20–33 % and committed
to a wrong edge in 67–80 % of instances: the boundary is where the
instrument's honesty ends. Every eligible repair restored the assertion
without displacement (0 / 36 seeds moved, ≤ 8.0 %), and the joint cells
were restored only where both faults were eligible.

**What was found instead.** (1) The floor bit exactly where the preregistered
design said it would: the certified stratum thinned to 15–23 seeds by
construction failure and background.
(2) Endogenous background sat on
the target token in 7–11 seeds per N = 6 stratum and put those instances
beyond `K_MAX`; the diagnostic's certificate on its *own* returned
support then licensed a confident wrong verdict in most of them — the
N-tribe economy's seven-in-eight (§8), reproduced at the assertion boundary.
(3) The forced rows could not expose the G contrast under I because the
candidate pool collapses to the target token, and the both − I-only
contrast was unobservable in every joint cell. (4) Every stratum is
low-background and refusal-dominated: the generator's own divergence
decodes to nothing on a fifth of horizon rows.

**Limit.** Planted-only; no organic collision; attribution under
endogenous background exercised in 4 certified instances; N = 6 only for
the primary. Nothing here bounds loop attribution between two models
speaking English (§13, "shared English is a surface, not a codebook").

**Allocation of burden.** *Translation determines the concept, evidence the
entity, authority whether the act proceeds; containment is a construction
identity, not a capability; attribution is exact inside a proved boundary
that the allocation could not bound and confidently wrong outside it; repair
restores without displacement wherever it is permitted to run, and is
permitted only after identification.*

## 12. Limitations and Deferred Work

Stated as commitments, not hedges:

1. **Abelian only.** Offset+exception maps commute; token relabelling (the
   second hop's lookup depending on the first hop's output) is the
   non-commutative seam, identified but unbuilt. Composition (`then`) is the
   documented extension point.
2. **Shared semantic substrate.** Correspondence is given, not discovered:
   anchors arrive as (token, code, code) for a known shared referent, and
   exceptions key the same token identity through every hop. The system
   calibrates divergent *representations* over a known shared *semantics*;
   unsupervised discovery that two independently minted concepts co-refer —
   and the genuine relabelling of item 1 — are deferred together. "Translation"
   here means register calibration, not referent matching.
3. **Exact factorisation reaches arity ≤2.** The recoverer of §7.3 covers the
   farmed corpus (compression mints binary) but refuses a faded
   three-or-more-component definition; scaling past the exact regime is the
   published sparse-block-code soft-resonator line (superposed estimates),
   deliberately not reimplemented here.
4. **Attribution is bounded, not solved.** One triangle attributes nothing
   (the λ = 2 case of Proposition 2), and multi-loop attribution (§7.4) is
   exact only within 2s < λ(G) — outside the boundary the instrument refuses,
   and a λ-cut of corruption makes the truth non-minimal. Evidenced-edge
   repair is unlocked exactly as far as the boundary reaches. Proposition 2
   is moreover an identifiability bound, not a tractability bound: the
   reference solver exhaustively searches supports through s ≤ 4, so
   corruptions that are uniquely recoverable in principle (2s < λ) but wider
   than the cap draw the named refusal rather than an answer — e.g. an s = 5
   corruption on the λ = 12 circulant, which k_max = 5 recovers uniquely and
   certified in milliseconds (pinned); larger sparse
   corruptions need a dedicated sparse decoder or optimisation method.
   Paper 3 measured both sides of that boundary at the assertion
   boundary. Inside it — a verdict certified by the proved sufficiency
   criterion on its own returned support (Proposition 3′), the truth
   within the s ≤ 4 cap — every one of the certified verdicts on 36
   held-out seeds recovered the complete constructed support and residual;
   the rate is 1.0 in all four N = 6 strata but is *unsupported at this
   allocation* (15–23 contributing seeds against a preregistered floor of
   25), so it is reported as an observation, not an estimate. Outside it,
   the instrument is confidently wrong: where the target token carried
   endogenous token-specific background on more than four edges, the
   attributor refused in 20–33 % of instances and committed to a wrong
   edge verdict in 67–80 %, with the certificate on its *returned* support
   licensing the commitment — the certificate certifies uniqueness of the
   minimum-support solution the enumerator can reach, not the truth. At
   λ = 2 (N = 3) it withheld on every instance (1.00 [1.00, 1.00] over 35
   seeds, wrong commitments 0.00). The cap is an instrument limit, not an
   admission boundary: instances beyond it are admitted, labelled, and
   reported. The
   noisy regime — corrupted rather than exact cycle measurements — is
   deferred to the CEMP literature it specializes. For a single corruption
   the boundary is now local and exact (Proposition 3, §9): λ(u,v) of the
   accused edge's endpoints, not λ(G). For general s the same cut argument
   proves the sufficient local condition — every cut meeting the corrupted
   edges carries more clean edges than corrupted ones (Proposition 3′, §9;
   the proposition note, Receipt A) — which reduces to λ(u,v) ≥ 3 at
   s = 1. Its converse is false for s ≥ 2: a cut can violate the condition
   and still be unable to cancel two corruptions at once, so uniqueness
   survives (six-node instance in the note). The exact boundary for
   residuals in general position is a forest condition on the cut's quotient
   graph, verified against the solver on 39,339 instances over seeds 1–32
   (the Proposition 3′ falsification harness; pinned, Receipt B).
5. **Synthetic world.** The farm is a deterministic model of contact, not a
   corpus; §9 replaces *authored* contact with *emergent* contact, but the
   world remains synthetic, and
   the emergent-communication comparison is structural, not empirical.
   The candidate real-data follow-ups are populations of LLM agents and the
   agent runtime's own long-lived simulation streams; the world-grounded-seed
   composite experiment of §10 has been run (Paper 3, §11) and inherits this
   limitation twice over: its translation fault is planted (Proposition 1's
   swap, written as map entries on the hop used), its certified instances
   were baseline-clear in all but four seeds, so attribution amid naturally
   occurring competing residuals is *not established*, and every stratum is
   low-background (median per-pair exception rate below the farm's rate at
   idiosyncrasy 0.2) — adequacy of the offset+exception class is established
   in all eight strata, but as a planted-only boundary result.
6. **Merger irrecoverability** is a boundary of listener-side repair, not of
   the framework; context-based disambiguation is future work and belongs to
   the agent's reasoning layer, not the translation layer. Paper 3 met this
   boundary as a design fact: its translation fault had to be realised as
   the *swap* of Proposition 1 rather than the merger, because a merger
   cannot satisfy the closure predicate "both receptions decode the target
   token to the intended concept" except by the decode tie rule (Amendment
   1; the preregistration record, Receipt C). Under the
   swap, repair is exact and atomic: both entries overruled by their own
   certified verdicts, the derived inverse and both receptions rebuilt, and
   no seed exhibited displacement of the inconsistency (0 of 36, one-sided
   95 % Clopper–Pearson ≤ 8.0 %; the 5 % line would need 0 of 59 and is
   unsupported at this allocation).
7. **Deferred by decision.** Three of the round-2 panel's demanded runs were
   not manufactured, and are recorded here with their reasons rather than
   softened:
   - **E2, §8 with nonzero register drift — not run: intervention not
     expressible without changing the model.** The economy learns maps once
     and speaks every task in topic 0, so drift is inert there by
     construction; making the loop channel exercisable needs
     topic-conditional production and contact-dependent re-anchoring, i.e. a
     new experimental system. Recorded as a modelling result, not
     manufactured; the successor experiment's design is preserved in
     the panel record (Receipt A, round 2, §E2). (The N-tribe economy of §8, with
     drift on, is that successor's first form; its verdict stands there.)
   - **E3, an external method on the §7.4 measurements — deferred.** A CEMP
     implementation is a separate algorithmic comparison, not a missing
     replication; it does not gate this paper.
   - **E4's Zipf axis — deferred, not manufactured.** The schedule and tariff
     factorial's horizon axis (the five-epoch boundary stated in §8) and config axis
     (config A's window, §8) are done; the Zipf exponent is not a knob today
     (the Zipf weight is fixed at 1/(r+1)) and is deferred rather than manufactured to
     complete the factorial. The remaining tariff and ledger axes (the joint
     tariff grid, injected quirk rate, priced monoculture enforcement,
     per-tribe ledgers) are open and not owed.

## 13. Discussion: What This Work Is For, With Every Claim Labelled

Every claim below carries one of five labels:

- **[P] proved in the construction** — a proposition with a proof, checked
  by the falsification harnesses;
- **[M] measured in the synthetic economy** — a pinned number from §8, the
  round-2 runs, or the preregistered grids (§8's N-tribe economy, §11);
- **[¬E1] not supported by E1** — a claim the audits-off run withdrew;
- **[A] architectural implication** — follows from [P]/[M] as a design rule,
  without a further experiment;
- **[T] transfer hypothesis** — plausible in real agent systems; not shown
  to produce the paper's mathematical object (known co-reference, sparse
  block codes, inspectable maps, additive composition, measurable residuals).

### 13.1 The proposition

Let local minds compress, and put the interpretability burden on
inspectable machinery between them — with a proof of what that machinery can
and cannot fix. **[A]**, resting on [P] and [M] below.

If agents remain short-lived and centrally prompted, this is principally a
formal result. If agents persist, specialise and develop local shorthand, it
offers a testable alternative to forced uniformity: preserve local
compression, expose translation relationships as inspectable state, repair
only what remains identifiable, and never treat mutual coherence as evidence
of truth. **[A]** as a design; **[T]** as a claim about any real fleet.

### 13.2 Five things understanding it buys

**1. A permission structure for local efficiency.**
Divergence supported by definition shipping and descent repair beat both
forced uniformity and unrepaired drift inside a measured in-model bandwidth
window (0.155 < w < 0.611 at the reference seed; 0.2556 < w < 0.4831 common
to sixteen seeds; open at every seed under both growth configurations). **[M]**
The window is a property of horizons long enough to repay prepaid
instruments: closed at three and four epochs for two seeds, open from five,
widening with horizon. **[M]** Definition-shipping consumed 64% of the
instrument bill and still recovered its cost over the tested horizon, because
descent repair converted a recurring failure into recurring successes. **[M]**
Loop auditing added no measured marginal value in the tested zero-work
regime: +3.0 wire at every seed, successes +2 / 0 / −1, window unchanged.
**[¬E1]** So the decision rule "farm or fight, computed from traffic" is
evidenced for provenance instruments; it is not yet evidenced for loop
instruments. **[A]**

**2. A defect pairwise testing cannot certify.**
Every direct pair can hold mutually inverse translations while A→C directly
differs from A→B→C: path dependence in the population register, a
translation-coherence defect distinct from collective wrongness, which is a
truth defect. The loop's residual is a signed, block-indexed vector, not a
score. **[P]** (§4, §6.2; identity pinned at seeds 1–32.) Pairwise testing
may still observe symptoms; what it cannot do is certify global path
consistency. **[A]** That a 3-cycle over a shared task set would surface
register disagreement in a real fleet: **[T]**. In the model, common-mode
register drift bends the loop without breaking a single decode — the audits
flag it while comprehension never fails — so surfacing is not the same as
repairing. **[M]**

**3. Repair that is constructive and bounded.**
Repair restores exactly what production preserved: exact comprehension is
restorable iff production was injective on the tokens in play; a merger
cannot be wished back into a distinction. **[P]** (Proposition 1; 888
planted collisions never restored both words.) Which of two colliding words
survives is the decoder's tie rule, not the operator. **[M]** An edge that
already holds direct evidence is not patched automatically: refusal fired
in 70 of 70 cases where an abduced excess met evidence. **[M]** "Until more
loops can blame" is a mechanism (§7.4's overrule) with a proved boundary
**[P]** and a measured behaviour on authored graphs **[M]**; its operation
inside a running economy is what the N-tribe experiment measured (§8), and
its operation at the assertion boundary is §11.Automatic repair is therefore justified only when production preserved the
distinction, the defect is representable by the operator, the target edge is
identifiable under the available evidence and eligible for automatic
modification, and no direct evidence is silently overruled. **[A]** Gate
automatic repair on the certificate; refuse otherwise. **[A]**

**4. Attribution has an exact boundary, and it is not connectivity alone.**
With a single corruption, blame is unique iff the accused edge's endpoints
have local edge connectivity at least three. **[P]** (Proposition 3; 80/80
and 23/23 on the emergent graph; zero exceptions across seventeen boards.)
With several corruptions, blame is unique whenever every cut through the
corrupted edges carries more clean edges than corrupted ones; the converse
is false — a violating cut may be unable to cancel two corruptions at once,
so uniqueness survives — and the exact boundary for generic residuals is a
forest condition on the cut's quotient, agreeing with the solver on 39,339
instances. **[P]** (Proposition 3′.) Outside the boundary the solver's
verdict can be confidently wrong, not merely ambiguous, because the true
corruption is non-minimal. **[M]** (λ-cut converse; N ≥ 6 smoke runs; §11's
67–80 % wrong commitments beyond the search bound.) So:
connectivity constrains identifiability; it does not decide blame, and
"more agents ⇒ we know who was wrong" is false. **[A]**

**5. Coherence separated from truth.**
A flat triangle can be three agents all wrong about the world. Holonomy is a
property of the relationship layer; grounding stays in the world's record.
**[A]** (§10 "coherence is not truth"; the join to *Where Reliability
Lives*.)Calibrate translations beside ground, never instead of it. **[A]**
Maps, genealogies, residuals, refusals and overrulings are ordinary triples;
the episode is walkable. **[M]** (trail rows pinned.)

### 13.3 Where those gains would show up — as a roadmap, not evidence

Long-lived multi-agent work; heterogeneous model networks; schema and
tool-name drift; incident triage (world violation vs private false belief vs
translation failure, each with its own repair); metered agent traffic. All
**[T]**. A heterogeneous agent network cannot safely assume one stable
embedding or ontology space **[A]**; that loop residuals would be the cheap
witness there **[T]** — and in the model, cheap only over maps learned once
and tolerated stale, since relearning every edge every round at the §8
tariff loses to forced uniformity at every price from N = 6. **[M]** The
instrument's demonstrated operating regime is collision-shaped production
error; its economic claim is reserved to that regime, and the preregistered
N-tribe verdict (§8) confirmed the negative outside it. **[M]**, **[¬E1]**

### 13.4 What is not cashed

The algebra is exact because the world is a sparse block code with given
co-reference. Real agents have messy tokens, non-commutative composition,
unsupervised meaning matching and noisy measurement. The transferable gains
today are architectural: separate growth repair (genealogy) from drift
repair (offsets); never auto-patch an evidenced edge; treat pairwise success
as insufficient; price instruments against bandwidth; keep coherence off the
truth path; gate automatic repair on the certificate. **[A]** The numeric
gains are in-model and justify the design and its boundaries; they are not
a lift quotable on a benchmark or a customer fleet. **[T]**

### 13.5 Where this sits for general AI — shared English is a surface, not a codebook

**The gap, stated exactly.** Two agents can emit the same sentence and not
have performed the same bind. The string is public; the internal state it
is a lossy readout of — training data, tokeniser, depth, quantisation,
post-training, tool fine-tunes — is private and frozen at bake time. A
shared dialect means the exception table is *invisible*, not that it is
empty. **[A]**, as a reading of the model; **[T]** as a claim about any two
deployed models.

**Where the loss sits when both sides speak English.** Lexical translation
is the small term. The large terms are (i) *comprehension variance as a
hidden map*: two models decode "the lease on shaft 17" to the same tokens
and do not share the neighbourhood of "lease", "shaft", or the pragmatic
"this is an alter, not an observe" — a token-conditioned offset nobody
installed, noticed only when the submitted entity or the tool argument is
wrong; (ii) *compression as forced idiosyncrasy*: a smaller or quantised
model is not a subset of the larger one but a different farm — rare senses
collapse and long-tail entities merge onto high-frequency neighbours, which
in the algebra is the many-to-one carry that Paper 3 removed from its
factorial as I-b and that Proposition 1 says translation repair cannot
undo; (iii) *the generation gap as unanchored mint*: a long-running agent
is a frozen seed plus a private history, and entities, ops and
institutional facts that arrived after its bake can only be bound through
atoms it already has — the growth channel (§7.1) meeting a world under
authority (§11), where the concept may mint, the evidence may point at the
wrong id, and the ledger still sees only the submitted tuple. All **[T]**;
(ii) rests on **[P]** (Proposition 1).

**The regime condition, revised.** The earlier assessment in this note's
history held that the studied regime needs independent local semantic
adaptation *plus* independently learned pairwise translations, and that a
shared external canon — human language, central schemas, governed tool
contracts — prevents it. The correction is accepted with one caveat: the
regime does not require invented dialects; divergent sparse experience plus
a frozen encoder already supplies the first half, and a mixed estate
(English between some pairs, schemas between others, old agents speaking
yesterday's ontology at new ones) supplies partial anchors. **[T]** The
caveat is the second half: between two foundation models there is no
learned `TranslationMap`, only a different geometry. An evaluated pairwise
certified-vocabulary object does exist — Schoenegger, Carlson, Schneider &
Daly's verifiable semantics for agent-to-agent communication
(arXiv:2602.16424): two agents, certified terms, recertification on drift,
with transitivity left as future work — and Yuan et al. (arXiv:2604.02369)
find only limited protocol-level support for semantic verification across
eighteen agent communication protocols. What does not exist is a translation map with a
loop residual and refusal across three or more heterogeneous agents; the
object the holonomy instrument reasons about is that one, and it is unbuilt.
**[A]**

**Why a shared plane does not dissolve it.** SPO triples, tool schemas,
function-call protocols and a common ontology move the seam; they do not
delete the three layers. The triple is still produced by a model that bound
"shaft 17" its own way (translation in RDF clothes); still grounded
against someone's evidence view (G, not syntax); still authorised or not (a
perfectly typed alter from an actor without the lease is an A failure with a
clean parse). A shared plane is the right engineering target because it
makes maps, evidence and leases inspectable, not because it guarantees
that A→B and B→C compose. **[A]**

**What Paper 3 can and cannot stand in for.** Planted I-a is a fair cartoon
of one hidden exception on the hop that is used — "the clerk decoded the
intended word onto a neighbour sense the speaker did not mean". It is not a
cartoon of distributional drift across two foundation models, where there
is no exception table to attribute over. The §11 grid must not be read
as evidence that loop attribution will name the guilty hop between two
proprietary models chatting in English; that needs an explicit
correspondence layer — anchors, probes, schema alignment — or it is
symptom-based diagnosis, which the preregistration refuses. **[A]** The
honest transfer is narrower: path-dependence of meaning is already
happening in English as comprehension variance and generation gap **[T]**;
it becomes operationally real at the assertion — the tool call, the lease,
the write — not at a text-similarity score **[A]**; repair that patches the
sentence does not restore the act if evidence was consulted for the routed
sense or the new model minted a node the old one cannot invert **[A]**,
resting on Paper 3's staged path; authority can contain the write but
cannot make two agents hold the same bind **[A]**.

**The design implication.** If the future is mixed generations on a shared
world, the scarce resource is not a universal language but *anchors that
survive a bake*: a shared plane where it can be had; named refusal when the
hop is unanchored or the evidence is mixed; leases keyed on world ids, not
on whoever produced a fluent description of the id. The old agent bound to
a world that grew after its bake is the faded definition with a live
ledger — already the programme. The missing engineering piece is making the
hidden English map as inspectable as `TranslationMap`, or declining to
assert when it is not. **[A]**

**What this does and does not change in the ruling above.** It does not
make tribalism a present-day product mandate, and it does not rescue the
loop as standing infrastructure: the N-tribe negative and the re-anchoring
harm stand **[M]**. It sharpens where the programme's consequence lies —
the assertion boundary in a mixed estate — and names the one build that
would let the instrument apply there: an explicit, inspectable
correspondence layer between models, with refusal as the default when it
is absent. **[A]**

### 13.6 What Paper 3 found — the three layers at one assertion, labelled

**Established.** The three layers compose without impersonation: in
2,104 admitted cells the submitted tuple went wrong exactly when the
construction said (mismatch iff G ∨ I, contained iff mismatch ∧ A), the
ledger refused a revoked lease on a perfectly decoded and grounded
tuple, and repaired evidence never repaired a swapped decode. Eligible
repair restored the intended act without displacing the fault: no seed
exhibited *moved*, 0 of 36, ≤ 8.0 %. At λ = 2 the attributor withheld on
every instance and committed to nothing (1.00 / 0.00 over 35 seeds).
Adequacy of the offset+exception class is established in all eight
strata. The N = 6 composite by cell vector is supported: G-only cells
restore always, I-only 0.67–0.81, joint 0.43–0.61. **[M]**

**Observed, not precision-supported.** Inside the proved boundary —
certified on returned support, within the search cap — every verdict
recovered the complete constructed support and residual, 1.0 in all four
N = 6 strata; but 15–23 seeds contributed against the floor of 25, so
the primary estimand is *unsupported at this allocation* and no bound is
issued. **[M]**

**The validity boundary, measured.** Outside the boundary the instrument
is confidently wrong: refused in 20–33 % of instances and committed to a
wrong edge in 67–80 % where the target token carried endogenous background
beyond the search cap, licensed by a certificate that certifies uniqueness
of the reachable minimum-support solution, not the truth — the N-tribe
economy's seven-in-eight reproduced at the assertion boundary, and the more
informative half of the result: a demonstrated boundary rather than a
success region. **[M]**, resting on **[P]** (Proposition 3′ and its
converse's failure).

**Not established.** Attribution under endogenous token-specific
background (the certified instances were baseline-clear in all but four
seeds; every stratum is low-background): the primary result is a
planted-only boundary result. The 5 % displacement line (needs 0 of 59).
**[M]** as absences.

**Structurally unobservable.** The both − I-only contrast on the forced
faulted-concept rows, in every joint cell: after I repair the token no
longer decodes to the routed concept, so the contrast the design wanted
cannot exist. Recorded as an observability limit of the construction,
not as missing work. Every stratum is refusal-dominated: a fifth of
entity-bearing horizon rows refuse at decode from the generator's own
unanchored divergence. **[M]**

**What it changes in the proposition.** Nothing in the ruling on
consequence or infrastructure. It adds the doctrine's executable form:
no translation instrument may impersonate grounding or authority, and
the instrument's own certificate must be read as certifying reachable
uniqueness, never truth. Automatic repair remains gated on
identification — and Paper 3 shows what the gate is protecting against.
**[A]**, resting on the **[M]** above.

### 13.7 The sentence

Divergence is allowed. Misunderstanding is typed. Some of it is
automatically repairable. Some of it must be refused. None of it is allowed
to impersonate ground truth. — the first paper's doctrine, applied to speech
between models. **[A]**

## 14. Conclusion

The contribution is not cycle consistency, holonomy, ontology alignment, or
the general idea of refusing an unsupported repair; those have substantial
prior literatures (§2). The contribution is an executable instance in which
independently evolved representational codebooks are calibrated without
imposing a common codebook; higher-order inconsistency is converted into a
local, constructive repair of the map itself; and the instrument's success
and refusal boundaries are measured under controlled semantic faults.
In a population of divergent sparse-block codebooks, the inconsistency of a
network of learned translations is itself represented in the
representations' own algebra — an exact, blockwise, auditable residual
rather than a scalar alarm — and within a provable boundary (Proposition 1)
that residual is directly reusable as the correction of the map. A
communication error invisible to every relevant two-agent check
was exposed by a third relationship, named per token, and repaired, with the
whole episode serialized as ordinary facts. The discrete realization is not a
compromise on the continuous versions of these ideas; it is the version with
an audit trail. Whether divergence *should* be farmed is no longer only a
design proposition: in the one economy we measured, farming wins exactly a
window of relative bandwidth cost and loses honestly on either side of it
(§8). What the experiments establish, in every configuration tried, is that,
farmed or not, divergence can be instrumented, and that the instrument's
limits (merger, the attribution boundary, the abelian class, the economy's
window) can be stated as precisely as its powers. Carried to one assertion
over a shared world (§11), the allocation of burden reads: *translation
determines the concept, evidence the entity, authority whether the act
proceeds; containment is a construction identity, not a capability;
attribution is exact inside a proved boundary the allocation could not bound
and confidently wrong outside it; repair restores without displacement
wherever it is permitted to run, and is permitted only after
identification.*

---

## References

- Alqithami, S. (2026). Preregistered belief revision contracts.
  arXiv:2604.15558 (preprint).
- Anslow, M., Rovatsos, M. (2015). Aligning experientially grounded
  ontologies using language games. In Croitoru, M., Marquis, P., Rudolph,
  S., Stapleton, G. (eds.), *Graph Structures for Knowledge Representation
  and Reasoning: 4th International Workshop, GKR 2015, Revised Selected
  Papers*, Springer LNAI 9501:15–31. doi:10.1007/978-3-319-28702-7_2.
- Beltoft, S.L., Brach, W., Torrielli, F., Nielsen, J., Pirchert, A.B.,
  Tonini, F., Schneider-Kamp, P., Poech, L.G. (2026). Emergent languages in
  populations of language model agents: from token efficiency to oversight
  evasion. arXiv:2605.31170 (preprint).
- van den Berg, L., Atencia, M., Euzenat, J. (2020). Agent ontology
  alignment repair through dynamic epistemic logic. *Proceedings of the 19th
  International Conference on Autonomous Agents and Multiagent Systems
  (AAMAS 2020)*, IFAAMAS, pp. 1422–1430.
- Bridgeland, D.M., Huhns, M.N. (1990). Distributed truth maintenance.
  *Proceedings of the Eighth National Conference on Artificial Intelligence
  (AAAI-90)*, Boston, pp. 72–77. AAAI Press.
- van Diggelen, J., Beun, R.-J., Dignum, F., van Eijk, R.M., Meyer,
  J.-J.Ch. (2007). Ontology negotiation in heterogeneous multi-agent
  systems: the ANEMONE system. *Applied Ontology* 2(3–4):267–303.
  doi:10.3233/AO-2007-034.
- Doyle, J. (1979). A truth maintenance system. *Artificial Intelligence*
  12(3):231–272. doi:10.1016/0004-3702(79)90008-0.
- Dragoni, A.F. (1992). A model for belief revision in a multi-agent
  environment. In Werner, E., Demazeau, Y. (eds.), *Decentralized A.I. 3:
  Proceedings of the Third European Workshop on Modelling Autonomous Agents
  in a Multi-Agent World (MAAMAW-91)*, North-Holland, pp. 103–112.
- Duncan, A.L., Kileel, J. (2026). Higher-order group synchronization.
  *Research in the Mathematical Sciences* 13(2):48.
  doi:10.1007/s40687-026-00627-w; arXiv:2505.21932.
- Euzenat, J. (2017). Interaction-based ontology alignment repair with
  expansion and relaxation. *Proceedings of the Twenty-Sixth International
  Joint Conference on Artificial Intelligence (IJCAI-17)*, pp. 185–191.
  doi:10.24963/ijcai.2017/27.
- Euzenat, J., Shvaiko, P. (2013). *Ontology Matching*, 2nd ed. Springer.
- Frady, E.P., Kent, S.J., Olshausen, B.A., Sommer, F.T. (2020). Resonator
  networks, 1: An efficient solution for factoring high-dimensional,
  distributed representations of data structures. *Neural Computation* 32(12).
- Frady, E.P., Kleyko, D., Sommer, F.T. (2023). Variable binding for sparse
  distributed representations: theory and applications. *IEEE Trans. Neural
  Networks and Learning Systems* 34(5). arXiv:2009.06734.
- Gao, T., Brodzki, J., Mukherjee, S. (2021). The geometry of synchronization
  problems and learning group actions. *Discrete & Computational Geometry* 65.
- Graesser, L.H., Cho, K., Kiela, D. (2019). Emergent linguistic phenomena in
  multi-agent communication games. *EMNLP*.
- Hansen, J., Ghrist, R. (2019). Toward a spectral theory of cellular sheaves.
  *Journal of Applied and Computational Topology* 3.
- He, J., Yu, D. (2026). Replicating belief, not bits: epistemic state
  replication for agentic systems. arXiv:2607.09748 (preprint).
- Hernández, M., Sánchez-Soto, E. (2026). The Cartan-Topos Protocol: a
  unified geometric and categorical framework for resilient multi-agent
  coordination. arXiv:2606.00714 (preprint).
- Hüttebräucker, T., Sana, M., Calvanese Strinati, E. (2024). Latent space
  alignment for semantic channel equalization. arXiv:2405.13511.
- Javidnia, H. (2026). A gauge theory of superposition: toward a
  sheaf-theoretic atlas of neural representations. arXiv:2603.00824
  (preprint).
- Jha, R., Zhang, C., Shmatikov, V., Morris, J.X. (2025). Harnessing the
  universal geometry of embeddings. *NeurIPS 2025*; arXiv:2505.12540.
- Jia, J., Deng, Z., Chen, Z., Wang, Y., Zheng, Z. (2026). MAS-FIRE: fault
  injection and reliability evaluation for LLM-based multi-agent systems.
  arXiv:2602.19843 (preprint).
- Jiménez-Ruiz, E., Payne, T.R., Solimando, A., Tamma, V. (2016). Limiting
  logical violations in ontology alignment through negotiation. *Principles
  of Knowledge Representation and Reasoning: Proceedings of the Fifteenth
  International Conference (KR 2016)*, Cape Town, AAAI Press, pp. 217–226.
- Kent, S.J., Frady, E.P., Sommer, F.T., Olshausen, B.A. (2020). Resonator
  networks, 2: Factorization performance and capacity compared to
  optimization-based methods. *Neural Computation* 32(12).
- Kirby, S., Tamariz, M., Cornish, H., Smith, K. (2015). Compression and
  communication in the cultural evolution of linguistic structure.
  *Cognition* 141.
- Kleyko, D., Rachkovskij, D.A., Osipov, E., Rahimi, A. (2022, 2023). A survey
  on hyperdimensional computing aka vector symbolic architectures, Parts I
  and II. *ACM Computing Surveys* 55.
- Kong, W., Lai, S., Piao, J., Evans, J. (2026). Multi-LLM systems exhibit
  robust semantic collapse. arXiv:2605.17193 (preprint).
- Laera, L., Tamma, V., Bench-Capon, T., Euzenat, J. (2006). Agent-based
  argumentation for ontology alignments. *Proceedings of the 6th Workshop on
  Computational Models of Natural Argument (CMNA 2006, at ECAI 2006)*, Riva
  del Garda.
- Laiho, M., Poikonen, J.H., Kanerva, P., Lehtonen, E. (2015).
  High-dimensional computing with sparse vectors. *IEEE BioCAS*.
- Lazaridou, A., Baroni, M. (2020). Emergent multi-agent communication in the
  deep learning era. arXiv:2006.02419.
- Lazaridou, A., Peysakhovich, A., Baroni, M. (2017). Multi-agent cooperation
  and the emergence of (natural) language. *ICLR*.
- Lee, J., Cho, K., Weston, J., Kiela, D. (2018). Emergent translation in
  multi-agent communication. *ICLR*.
- Lerman, G., Shi, Y. (2022). Robust group synchronization via cycle-edge
  message passing. *Foundations of Computational Mathematics*
  22(6):1665–1741. doi:10.1007/s10208-021-09532-w; arXiv:1912.11347.
- Levy, I., Paradise, O., Carmeli, B., Meir, R., Goldwasser, S., Belinkov,
  Y. (2025). Unsupervised translation of emergent communication.
  *Proceedings of the AAAI Conference on Artificial Intelligence*
  39(22):23231–23239. doi:10.1609/aaai.v39i22.34489; arXiv:2502.07552.
- Li, S., Shi, Y., Lerman, G. (2025). Cycle-Sync: robust global camera pose
  estimation through enhanced cycle-consistent synchronization. *Advances in
  Neural Information Processing Systems 38 (NeurIPS 2025)*;
  arXiv:2511.02329.
- Mellafe Zuvic, D. (2026). Capability gates are not authorization:
  confused-deputy failures in LLM agent frameworks (ScopeGate).
  arXiv:2606.28679 (preprint).
- Mishra, S. (2026). Local verification cannot detect non-transportability:
  a cohomological theory of context preservation in agentic reasoning.
  arXiv:2608.11252 (preprint).
- Olivieri, D.N., Hernández, R.J. (2026). Sheaf-theoretic transport and
  obstruction for detecting scientific theory shift in AI agents.
  arXiv:2605.14033 (preprint).
- Robinson, M. (2017). Sheaves are the canonical data structure for sensor
  integration. *Information Fusion* 36.
- Sana, M., Calvanese Strinati, E. (2023). Semantic channel equalizer:
  modelling language mismatch in multi-user semantic communications.
  arXiv:2308.03789.
- Schoenegger, P., Carlson, M., Schneider, C., Daly, C. (2026). Verifiable
  semantics for agent-to-agent communication. arXiv:2602.16424 (preprint).
- Sevetlidis, V., Pavlidis, G. (2026). Gauge-invariant representation
  holonomy. *ICLR 2026*; arXiv:2601.21653.
- Singer, A. (2011). Angular synchronization by eigenvectors and semidefinite
  programming. *Applied and Computational Harmonic Analysis* 30(1).
- Steels, L. (2015). *The Talking Heads Experiment: Origins of Words and
  Meanings*. Computational Models of Language Evolution 1. Berlin: Language
  Science Press. ISBN 978-3-944675-42-8.
- Theiss, J., Leverett, J., Kim, D., Prakash, A. (2022). Unpaired image
  translation via vector symbolic architectures. *ECCV*.
- Togia, T., McNeill, F. (2013). On-the-fly repair of structural and
  lexical ontology mismatches in multi-agent systems. *Artificial
  Intelligence Review* 40(2):175–191. doi:10.1007/s10462-012-9352-0.
- Xu, J., Fan, L., Wang, Z., Li, X., Liu, H. (2026). Beyond single-use
  tokens: durable authorization state for replay-resistant LLM agent
  actions (CapLease). arXiv:2608.01710 (preprint).
- Yuan, D., Lyu, F., Yuan, Y., Zhang, W., He, B., Geng, J., Du, L., Sun,
  Z., Chen, Y., Han, C., Kang, J., Chen, X., Wu, H., Liu, X. (2026). Beyond
  message passing: a semantic view of agent communication protocols.
  arXiv:2604.02369 (preprint).
- Zhang, S., Wang, A., Lei, S. (2026). Layer-isolated evaluation: gating
  the deterministic scaffold of a production LLM agent with a no-LLM,
  regression-locked test harness. arXiv:2606.11686 (preprint).

## Appendix A: Reproducibility

**Where the record is.** The experimental record — code, tests, harnesses,
result grids, the panel record and the preregistration chain — is frozen at
tag `fractal-tribalism-v1.2` of a private repository. This note publishes
its verification, not its machinery: the SHA-256 identities of the note, the
pin files, the result grids and their validated manifests, the panel record
and the calibration freeze at the tagged commit are in the accompanying
artefact manifest; the test run and every command below, executed from a
fresh clone at the tag, are Receipt B of the accompanying verification
receipts; the review panel is Receipt A, the Paper 3 preregistration chain
Receipt C, and the N-tribe economy's preregistration and confirmation
Receipt D. Reviewers may request supervised access to the record via
hello@taniwha.ai.

**What is pinned.** Every deterministic claim-bearing figure in the main
text — floats included — is asserted exactly by a test in the record: the
main pin suite (which also reads this note to pin the claim-bearing prose
configurations, such as §8's epoch × task header), with §6.5's counts in
the scaling suite, under a contract that is the reverse of a normal test's:
pins are never loosened; if one breaks, the paper is what gets corrected.
The run of that suite from a fresh clone at the tag — 501 passed, 13
skipped — is Receipt B. Machine-local timings are the only figures left
unpinned, and they are labelled indicative where they appear; the §6.5
N = 100 row's detection at seeds 1–8 is pinned per seed in the scaling
suite. Behavioural properties live in their own suites: separation, farming
dynamics, growth repair, the closed loop (including the evidenced-edge
refusal regression of §7.2's corollary), memory wiring and decay, exact
signature factorisation (§7.3's measurements are self-calibrating assertions
there, with the depth arithmetic spelled out in-test, and the ambiguity
refusal constructed explicitly for both the one-missing and two-missing
branches), population scaling, multi-loop attribution (the §7.4 table, the
one-triangle and single-cycle λ = 2 refusals, the cancelling-quirks
recovery, the λ-cut converse, unique-without-certificate, and the overrule
circle), the task economy (the §8 regime table, exact crossover ratios, the
tariff-sensitivity ceilings and 16-seed window fractions, the horizon and
config-A windows, the audits-off (E1) ledger, the M × cross-fraction knob
grid with its corner seeds and its one closure, the merger inventory and its
never-repaired assertion, the repair-as-investment exemplar, monoculture's
zero-failure linearity), emergent geography (tribe structure and
clustering, the locale rates and their λ(u,v) and degree means, the
zero-exception λ(u,v) cross-tab behind Proposition 3 and its seventeen-board
sweep, the emergent-schedule crux and its flattened-register control), and
the assertion-boundary experiment (§11's figures against the frozen
scientific object). The seeds-1–32 sweep and the §6.2 identity (asserted at
every seed) are in the main pin suite. The closed cell's third crossing —
337/1241.75 ≈ 0.271, unfarmed over monoculture in the M = 16 × cross = 0.2
cell — is pinned only in the economy suite; no listed command-line driver
reaches it (the economy driver has no cross-fraction knob; the knob sweep
prints only the two window edges). The abstract's "serializable as
subject–predicate–object triples" has three serialization witnesses in the
record: a genealogy-facts round trip, a chronicle round trip through the
memory roll, and a runtime versioned-JSON round trip that preserves
decisions and gate state.

**The propositions are attacked, not only proved.** A falsification harness
drives Propositions 1–3 through the actual modules on four adversarial graph
shapes with random supports satisfying 2s < λ, ~954k instances over seeds
1–32, zero counterexamples, exit code 1 on any hit — the seventh panelist of
the reliability programme; a second harness does the same for Proposition
3′, its refuted converse and the exact general-position criterion (39,339
instances, seeds 1–32; pinned at seed 7). Both harnesses and their counts
are in Receipt A and Receipt B.

**Drivers.** Each experiment has a command-line driver in the record — the
farm (seed 7, 30 epochs), the scaling harness (seed 7, 30 agents, 5
quirks), the attribution harness (seed 7, 30 agents, degree 5, 3 quirks),
the economy (seed 7, sweep; with an audits-off switch for E1's
genealogy-only regime), the knob sweep (seed 7, 16 corner seeds), and the
cellular-automaton borders sweep (seed 7; with a farm-feed mode for the §9
crux) — and every one of those invocations was run from a fresh clone at
the tag as part of Receipt B. No RNG state anywhere: every draw is keyed by
(run seed, label).

**Paper 3 (§11).** Design freeze
`f8b1f2dcc1aab2d5de989bb18ff732b48324e766` (v0.19) with Amendments 1 and
2; implementation signature 2 at `daea9a5` (blob hashes and verbatim
quotations of every named function; Receipt C); calibration freeze
(Receipt C; fitting 1001–1500, validation 2601–3100, farm references
2001–2100; the first validation range 1501–2000 retired after diagnosing a
validator defect, Amendment 2); development 101–116; held-out 117–152, run
once on the compute host from `daea9a5`; validated manifests attributing
every stratum to one producer with identical generative blobs (288 / 288);
the scientific object `e39916e`; §11's figures pinned against it in the
record's own suite. Smoke seeds 9001–9002 are feasibility pilots outside
every allocation. Seeds 117–152 are never reused. The whole chain —
freeze, amendments, signature, calibration validity, development and
held-out accounts, manifest — is Receipt C.

Evidence snapshot: tag `fractal-tribalism-v1.2` — v1.2 folds Paper 3 in as
§11 and absorbs the two panel edit rounds with no claim revisions; the
externally reviewed claim set was frozen at tag `fractal-tribalism-v0.4`,
and every tag from v0.5 (§7.3 and the memory integration, now §10) through
v1.1 (the §8 knob-sweep pins) was additive except v0.6, which revised
exactly one claim — the §7.2 corollary's scope — at the fifth review round's
direction. Four witnesses (two Windows machines, a Linux host, hosted CI)
reproduced the 169 tests and the knob-sweep grid bit-identically at v1.1. A
second witness exists in the internal record: an independent review that
re-ran every cited test on the pure-Python backend and checked
Proposition 1's proof.

## Appendix B: Notation Map Across Communities

| this paper        | gauge theory | group synchronization | sheaf theory (informal here)         | other                                  |
|-------------------|--------------|-----------------------|--------------------------------------|----------------------------------------|
| loop defect       | holonomy     | frustration           | failure of a 1-cocycle / gluing obstruction | —                               |
| abduction         | —            | —                     | obstruction-driven extension         | hypothesis generation (Peirce)         |
| divergence farming| —            | —                     | —                                    | language contact in a population       |
| edge attribution  | gauge fixing | cycle-edge message passing (CEMP) | —                        | —                                      |