Operator 13b — Cross-Namespace Meta-Model Genus Probe¶

A proposed, un-run variant of Operator 13 (Cluster-Without-Parent), with a concrete algorithm, one worked example, and honest yield expectations¶

Status: PROPOSED. Not yet run. A method without a sweep is a hypothesis, not a result — held to the operator paper's own "we ran it, here is the yield law" standard, this note is a hypothesis plus a single hand-found worked example. Written 2026-07-11 so it can be picked up cold. Owner: Kurt.

Executive summary¶

Operator 13 ("cluster-without-parent — the missing ancestor") was run as a full sweep and saturated: zero new primes, twelve missing-edge sets. Its universal collapse mode was parent-already-exists — every coherent cluster's natural genus turned out to be already in the catalog, so the finding was edges, not a new prime.

Yet a genus that Operator 13 should have found — a candidate now drafted as fit_relative_competence — was missed by that sweep, and it was missed for a characterizable implementation reason, not because the operator concept is exhausted. Operator 13 as implemented (a) clusters the prime corpus only, (b) groups by k-means over full signature embeddings (which sorts by domain-flavored surface), and © reads parent-absence off the curated DAG. A structural family that is cross-domain (its members are embedding-distant because they wear different domain clothes), cross-namespace (some members live in the separate domain-specific corpus), and under- placed in the DAG (some members are unplaced or orphaned) is invisible to all three assumptions at once. The fit_relative_competence family is exactly that: members in biology, machine learning, dynamical systems, design, and cognition, spanning both namespaces, several outside the DAG.

Operator 13b is the same operator with three fixes: retrieve candidate genus-families by domain-stripped meta-model probes (the corpus's own documented cross-domain retrieval trick) instead of k-means; search both namespaces; and treat DAG-absence as a signal to check, not a precondition. This is not a new operator — the discovered object is still "a set's missing parent." Only the retrieval method and scope change.

Honest expectation: it will probably find little, possibly nothing beyond the one case that motivated it. Operator 13 saturated for real reasons (a mature catalog mostly has its genera). Operator 13b only adds the cross-domain / cross-namespace families that k-means fragmented — a subset, most of which will still collapse to parent-already-exists. The value is a completeness patch and a candidate counterexample to the 0-new result, not a discovery engine. And the final adjudication step (is the proposed genus genuinely distinct, or a restatement of an existing prime?) does not mechanize — it stays a human/LLM judgment and is the true bottleneck. Build the full sweep only if a cheap sniff test (below) shows marginal yield > 0.

1. Background: Operator 13 and why it saturated¶

Operator 13, from the-operator-compendium.md §13: "look for tight little groups of primes that plainly hang together… check the hierarchy to see whether they have a common ancestor… when a coherent cluster has no shared parent drawn above it, that absence is the signal: either the family needs a genus that nobody has named, or it needs edges up to a genus that already exists. Naming the missing ancestor is the move."

Its run: k-means over fresh signature embeddings → 82 coherent clusters → 0 new primes, 12 parent-hub edge sets. Worked collapse example: {fail_safe, fault_tolerance, poka_yoke, validation} → proposed parent robustness → but robustness already exists → finding is missing edges, not a new prime. The paper frames this zero as predicted and informative: "naming the shared genus of things already present is exactly the move the catalog's builders made by hand… the operator had, in effect, already been run reactively for years."

The three implementation assumptions that produced the saturation:

Prime-corpus only. The clustering ran over primes. The separate domain-specific corpus (~1,171 records) was not pooled in.
k-means over full signature embeddings. Embeddings encode domain-flavored surface as well as structure, so items are sorted partly by domain. Structural siblings that live in different domains land in different clusters.
DAG-dependent parent check. "Is there a common ancestor?" is read off the curated subsumption DAG, which is sparse — many primes are unplaced, some are orphans.

Each assumption is reasonable; together they define a blind spot.

A candidate missing genus is invisible to Operator-13-as-run when its family is:

Cross-domain / embedding-distant. The members instantiate one structure but wear different domain vocabularies, so their embeddings are far apart and k-means files them in different clusters. The convergence is structural, not surface — the hardest case for similarity clustering.
Cross-namespace. Some members are domain-specific entries, not primes, so a primes-only clustering never sees them — and the domain-specific member is often the most on-the-nose instance.
Under-placed in the DAG. Members are unplaced or orphaned, so the "shared ancestor?" check has nothing to read.

Illustration — the fit_relative_competence family (the one we hand-found):

member	namespace	DAG status	domain
`ecological_trap`	domain-specific	n/a	behavioral ecology
`shortcut_learning`	prime	under `adaptation`	machine learning
`no_free_lunch_theorem`	prime	unplaced	optimization/search
`release_from_controlling_context`	prime	orphan	dynamical systems
`affordance`	prime	in a design cluster	perception/design

Five instances of one structure — a mechanism's value is a function of its fit to its environment, so the same structure is a strength in-fit and its own characteristic failure out-of-fit — spread across five domains, two namespaces, and mostly outside or under-connected in the DAG. Operator-13-as-run could not have assembled this set. Operator 13b is built to.

3. The core idea¶

Replace cluster-and-hope-siblings-land-together with probe-and-pull-the-family. The corpus's own retrieval is designed for exactly this: search_prime's instructions say to query with "the abstract structure with no domain vocabulary — the meta-model… retrieves dramatically better across domains." So instead of trusting k-means to co-locate structural siblings (it won't, across domains), we actively issue a domain-stripped structural query and let semantic retrieval gather the family — across both namespaces. Then apply Operator 13's own back half unchanged: check for a shared parent; if absent and the genus isn't already named, that's a candidate.

The seed that started us (an application-level idea from the Abstractopia biases thread) was not essential — it was one way to get one probe. The corpus can generate its own probes from every prime's structural_signature. That is what makes this a crank rather than a spark.

4. The concrete algorithm (the crank)¶

Inputs: the prime corpus + the domain-specific corpus; the MCP read tools; an LLM for abstraction, coherence judgment, and distinctness adjudication.

Step 1 — Probe generation. For each prime P, take P.structural_signature (via get_prime(P, summary)), and LLM-abstract it into a domain-neutral meta-model string: strip domain nouns, keep the relational skeleton (roles + relations + the invariant). Yields ~1,325 probes. Dedup: embed the probe strings and cluster them; keep one representative per tight cluster, collapsing ~1,325 raw probes to a few hundred distinct structural queries. (Optionally also seed probes from domain-specific structural_signatures, and from pairs of embedding-distant primes that share structural tokens.)

Step 2 — Cross-namespace retrieval. For each probe, run both search_prime(query, mode="neighborhood") and search_domain_specific(query); take top-k from each (k ≈ 15–20). Union → the candidate family for that probe.

Step 3 — Coherence filtering. LLM-judge each candidate family: "do these all instantiate one structural signature? State it. Which members are off-topic?" Prune off-topic members. Keep families with ≥ 3 coherent members spanning ≥ 2 distinct domains. (Cross-domain span is the whole signal; a same-domain family is usually already parented.)

Step 4 — Parent-absence check. For each surviving family, run get_prime_lineage(member, direction="up") on every member. - If they share a common ancestor already in the DAG → not a find; emit a missing-edge set (draw the members up to the shared parent). This is the expected majority outcome. - If no shared ancestor exists, and the family is coherent + cross-domain → candidate missing genus.

Step 5 — Genus naming + existence check (the collapse guard). Name the proposed genus. Then search both namespaces for it under any name (search_prime + search_domain_specific with the genus's own meta-model). If it already exists → collapse to an edge-harvest (Operator 13's universal failure mode — guard against it every time). If truly absent → candidate emergent prime.

Step 6 — Distinctness adjudication (does NOT mechanize; the bottleneck). Run the sibling test against the nearest existing prime — especially the presupposed parent. Is the genus a real abstraction all members are species of, or a restatement of an existing prime with a token stripped? Error-prone; owner-gated. Bias toward collapse-to-edges unless distinctness is clear.

Step 7 — Output. For survivors, draft an emergent-prime stub (frontmatter + Core Idea + Notes with provenance, proposed DAG edges, and candid keep/cut) in prime_abstractions/v2_density_pilot/, exactly like fit_relative_competence.md. Emit a manifest of all probes, families, coherence verdicts, parent-checks, genus proposals, existence-checks, and distinctness verdicts.

Pseudocode:

probes = dedup([ abstract_to_meta_model(get_sig(P)) for P in primes ])
finds, edge_harvest = [], []
for q in probes:
    fam = search_prime(q, neighborhood) ∪ search_domain_specific(q)
    fam = llm_prune_to_coherent(fam)                     # step 3
    if distinct_domains(fam) < 2 or len(fam) < 3: continue
    parents = [ lineage_up(m) for m in fam ]
    if shared_ancestor(parents):                          # step 4
        edge_harvest.append(edges(fam -> shared_ancestor(parents)))
        continue
    genus = propose_genus(fam)                             # step 5
    if exists_in_corpus(genus): edge_harvest.append(edges(fam -> existing)); continue
    if llm_distinct_from_nearest(genus):                  # step 6 (human-checked)
        finds.append(stub(genus, fam))                    # step 7

5. Worked example (the one case we have)¶

Retold as if Operator 13b had produced it bottom-up (it was actually found top-down, from the Abstractopia biases thread — but the point is that op-13b reaches it without that seed):

Probe (abstracted from shortcut_learning's signature, domain stripped): "a mechanism adaptive in the environment it is matched to and maladaptive when the environment shifts; value is a function of the match, so the same structure is a strength and its own characteristic failure depending on context."
Retrieval (both namespaces): ecological_trap (domain-specific), no_free_lunch_theorem, release_from_controlling_context, affordance, niche_construction; plus the cognitive instances availability_heuristic, confirmation_bias.
Coherence: genuine — one structure across biology, ML, dynamics, design, cognition.
Parent-absence: no_free_lunch unplaced; release_from_controlling_context orphan; shortcut_learning under adaptation, not a fit-relativity genus; no shared ancestor → seat empty.
Genus name + existence check: fit_relative_competence; absent from both namespaces.
Distinctness (step 6, the crux): vs adaptation — adaptation is the process; the genus is the relativity of the product's value, with the failure being the competence relocated. Judged distinct (pending owner screen).
Output: prime_abstractions/v2_density_pilot/fit_relative_competence.md.

Two illustrative probe styles (to calibrate what a good meta-model query looks like):

Structural, domain-free: "a quantity carried by the joint pattern across many individually unreliable elements, decoded into an estimate more reliable than any element" → would pull population_coding, wisdom_of_the_crowds, bayesian_cue_integration, redundancy — likely a collapse (their genus, roughly "aggregation of noisy independent estimates," may already exist; expect edges, not a prime).
Structural, domain-free: "an early contingent choice raises the cost of every later alternative until the system stays on it though a better option now exists" → path_dependence and kin — almost certainly already parented (a collapse). Most probes end this way; that is the point of the honest expectation.

6. Why it will probably find little (state this up front, every time)¶

Operator 13 saturated for real reasons; a mature catalog mostly has its genera.
Operator 13b only adds the cross-domain / cross-namespace families that k-means fragmented — a subset of all families, most of which still hit parent-already-exists.
The distinctness screen (step 6) kills marginal candidates and is the error-prone bottleneck.
Expected yield: a handful at most; plausibly just the one that motivated this. The reliable byproduct is the same as Operator 13's: a densification harvest of missing edges (and, here, edges onto currently-unplaced/orphaned nodes like no_free_lunch and release_from_controlling_context, which is worth something on its own).

7. Relationship to the operator catalog and the paper¶

Not a new operator. The discovered object is still "a set's missing parent." Operator 13b is a variant implementation — new retrieval method (meta-model probe) and new scope (cross-namespace), same move.
For operator-driven-discovery-of-primes.md: belongs in §8 (limitations / unturned stones) as a completeness caveat on Operator 13's saturation result — the sweep's k-means + primes-only + DAG-dependent implementation left cross-domain, cross-namespace, under-placed families unturned — and in §5.2/§5.3 (yield law / genus-convergence) as a candidate exception pending a sweep. Do not edit the paper on the strength of one hand-found case; edit it if the sniff test (below) yields a second.
Recursion worth recording: Operator 13's blind spot is itself an instance of fit_relative_competence — k-means-over-embeddings is a mechanism competent in its environment (embedding-adjacent, single-namespace families) and blind in a mismatched one (cross-domain, cross-namespace convergences). The candidate genus describes the failure mode of the very operator that should have found it.

8. Cheap validation before any full sweep (do this first, if anything)¶

The full sweep is ~hundreds of LLM abstractions + thousands of searches + a human adjudication tail — within the prior operator-sweep cost envelope, but not free. Before committing, run a 20–30-probe sniff test:

Hand-generate ~20–30 meta-model probes: some seeded from the fit/robustness/adaptation/ niche neighborhood (where a second find is most plausible), some from random primes (to estimate the base collapse rate).
Run steps 2–5 on them.
Decision: if even one second parent-less, cross-domain, genuinely-distinct family falls out → marginal yield > 0 → a fuller run and a paper edit are justified. If none does → Operator 13's saturation stands, fit_relative_competence was a lucky single, and the right conclusion is a one-paragraph §8 caveat, not a program.

Either outcome is cheap and decisive. Do not build the full sweep on spec.

9. Execution checklist for a future session¶

Tools: get_prime (summary, for structural_signature), search_prime (mode="neighborhood"), search_domain_specific, get_prime_lineage (up), get_prime_siblings; an LLM for abstraction (step 1), coherence (step 3), genus proposal (step 5), and distinctness (step 6).
Guardrails: always run the existence check (step 5) — parent-already-exists is the universal collapse; bias toward edge-harvest unless distinctness is unambiguous.
Artifacts: a run manifest (probes → families → verdicts) + emergent-prime stubs for survivors, in prime_abstractions/v2_density_pilot/, matching the fit_relative_competence.md format; sync any kept prime's one_liner across v1/v2 per CLAUDE.md at incorporation.
Owner gate: step 6 (distinctness) and final keep/cut are Kurt's call; the pipeline surfaces candidates, it does not adjudicate them.

10. Provenance¶

Surfaced 2026-07-11 in the Abstractopia biases design thread: Fable proposed teaching cognitive biases as "shadow modes" of epistemic-tool primes; pressing on whether "shadow mode" was itself an abstraction showed it to be a saturating composition (failure_mode ∘ epistemic-tool), but chasing it up — via a domain-stripped meta-model search across both namespaces, then a curated lineage walk showing an empty genus seat — produced the fit_relative_competence candidate. Generalizing that path is Operator 13b. Un-run. Kept on file so the rabbit can be chased when there is a reason to.