Octorato Isomorphism

---
name: octorato-isomorphism
description: "Octorato's three anchors (octopus, Linux, tesseract) are one structure shown three times, not three brands glued together. Names the abstraction method. Invoke when explaining why they cohere or when adding a new anchor."
metadata:
  type: identity
  short-description: "octopus ∧ linux ∧ tesseract share one structure; the shared words ARE the brain's required primitives. The fractal/self-similar primitive is owned by octorato-symbolism; this skill is the method that measures the invariant."
---

# Octorato Isomorphism

The three anchors look unrelated: a sea animal, an operating system, a 4-dimensional
polytope. They were chosen because they are the **same structure instantiated three
times**. In Hofstadter's terms (GEB) that sameness is an **isomorphism**; in cognitive
science it is Gentner's **structure-mapping**; in ML it is a **shared latent subspace**
(what CCA, Canonical Correlation Analysis, extracts from multiple views). Octorato's
own `connectome` already runs the ML version (TF-IDF + cosine).

## The method (why brute force is the wrong tool)

A user's instinct is to *generate* three huge corpora, strip synonyms, and keep what
lands in all three. That is correct in spirit and wrong in cost: 1.2M words carry
near-zero marginal signal after the first few thousand, and the answer is not in the
volume. Stated precisely, the operation is

    invariant  =  ⋂  ( anchor_i / ~ )        where ~ is synonymy

i.e. **set intersection over the quotient by synonymy**. Working in `V/~` is exactly
why "no synonyms" matters: each surviving word is a distinct dimension. This is the
same move as **Upward Learning** in CLAUDE.md — distill many instances to the generic
pattern *before* it enters the brain. The invariant is found by abstraction, never by
generation.

`scripts/octorato-isomorphism.py` computes it from `anchors.yaml` (config-first). The
honesty rule lives in the data: a word belongs to an anchor only if it literally
describes it. `adaptive`/`autonomous` describe an octopus and Linux but **not** a
tesseract, so they drop out of the intersection. That drop-out is the feature — the
script corrects hand-waved intersections.

## What the invariant says about the brain

Run the script and the result is a short list (≈10 words: distributed, isolated,
interconnected, layered, parallel, nested, symmetric, self-similar, emergent, bounded).
Map each to the primitive it implies and the finding is striking: **the brain already
embodies almost all of it** (arm-isolation, the connectome, the layer architecture,
session-isolation, two-tier memory, harmony, upward-learning, the QA merge gate). The
invariant is therefore a *coverage test*: any word in it with no matching primitive is
a real gap, and the only work.

## The fractal/self-similar primitive lives in octorato-symbolism

`self-similar` (canonical for recursive/fractal) is the deepest invariant: an arm is
itself a brain plus arms, the octopus repeats at every scale, the tesseract is a cube of
cubes, Linux nests namespaces within namespaces. That primitive has a home, and it is
**`octorato-symbolism`** — see its "superpower is recursion" / "fractal duality" passage,
where the brain↔arm self-similarity is named as the mechanism behind 8 → ∞. This skill
does not re-own it. The division of labour: symbolism carries the WHY (recursion is the
scaling mechanism); isomorphism carries the MEASUREMENT (self-similar is one of the ten
words that survive the intersection, which is how we know the metaphor is structural and
not decorative). Two skills, one primitive, no fork.

## When to use

- Explaining why the three anchors cohere (talks, launch comms, the manifesto).
- Adding a new anchor or metaphor: run it through the intersection — if it does not
  share the invariant, it is decoration, not structure.
- Deriving required primitives: the invariant is the checklist; gaps are the backlog.