# Operator-Driven Prime Discovery — Findings & Synthesis

**What this is.** A living synthesis of the operator-search program: the method, the results of
running it, and the cross-operator insights uncovered along the way. It is the perishable
counterpart to the durable machinery on disk — the raw data, templates, and manifests are
recoverable at any time, but the *assembled* picture (why the method is shaped as it is, what the
numbers mean across operators, and the hard-won methodological lessons) lives here. Written at the
natural milestone where **all unary operators are complete**; extended after each subsequent search.

**Status 2026-07-03.** **ALL UNARY OPERATORS COMPLETE** — 1, 2, 3, 4, 5, 6, 7, 8 + operator 13
(cluster-without-parent). Corpus frozen at 1,325 primes for the duration of the search; all emergent
finds accumulate as `prime_abstractions/v2_density_pilot/<slug>.md` stubs (**116 stubs**) for a
single end-of-search owner curation. Remaining: only the n-ary/combinatorial operators 9–12, 14
(run on pre-filtered pair sets, not full-corpus sweeps).

**Companion docs (canonical, read alongside):**
- `07_operator_prime_discovery.md` — the conceptual foundation (this doc assumes it).
- `OPERATOR_SEARCH_RUNBOOK.md` — the operational pipeline + the 14 operators.
- `operator_search/SATURATION.md` — the per-operator results table (the completeness ledger).
- `operator_search/templates/NN_*.md` — the reproducible Stage-0 machinery per operator.
- `operator_search/manifest_opNN_*.yaml` + `opNN/s4/shortlist.md` — per-operator finds + method notes.

---

## 1. The reframe, in one paragraph

Prime discovery is treated as a **graph search over concept-space**: the states are primes, the
moves are a closed set of **operators** (deterministic transformations that take a prime, or a small
tuple, and propose a candidate prime), and the visited-set is the existing corpus plus its alias
map. Discovery is node expansion — apply the move-set to the frontier, screen outputs against the
visited-set cheaply, keep what is genuinely new, repeat. Three things follow that mining and
reactive derivation cannot give: the search is **enumerable** (a closed move-set over a finite
corpus is a checkable job), novelty is **decidable cheaply** (the alias/embedding machinery is the
closed-list), and a **completeness claim** becomes measurable rather than asserted — if every
operator run to saturation stops yielding accepted primes, the reachable space is substantially
covered. The full argument, including the prior-art analysis (Pólya, category theory, FCA, TRIZ,
conceptual blending), is in `07_operator_prime_discovery.md`.

---

## 2. The operator set (and why it is closed)

An operator moves a structure along **one axis of variation**. The closure claim rests on
enumerating those axes, not brainstorming transformations. A single structure can move along its
polarity, its position in time, its scale/extent, its level of abstraction, its modal status, the
viewpoint it is read from, its linearity, and its relation to itself. Structures combine by
conjunction, opposition, proportion, and infilling. A collection reveals absences in exactly two
ways: a missing ancestor and a missing lattice cell. That is the whole set. If something is missing
it is a *sub-flavor* of one of these axes, not a new axis — which is the test for closure.

| # | Operator | Axis / move | Sub-flavors run |
|---|---|---|---|
| 1 | Dualization | polarity | logical-negation · opposing-force · failure-mode |
| 2 | Self-application | relation to itself | reflexive (R) · machinery (M) |
| 3 | Temporalization | time | level→flow · state→trajectory · present→anticipation |
| 4 | Spatialization / scaling | scale/extent | point→field · discrete↔continuous · micro→macro |
| 5 | Generalization (lift) | abstraction level | frame-strip → nearest genus |
| 6 | Modalization | modal status | actual→possible · deterministic→stochastic · mandatory→default |
| 7 | Perspective inversion | viewpoint | (not yet run) |
| 8 | Threshold / phase | linearity → critical point | gradual→tipping · continuity→discreteness |
| 9–12, 14 | n-ary / catalog-internal | combination / graph structure | (not yet run) |
| 13 | Cluster-without-parent | missing ancestor | (run; saturated) |

The deep reason the set matters: **an axis you never sweep is a systematic blind spot, not a random
one.** Mining misses primes at random; an unswept operator misses *every* variant of *every* prime
along that axis, all at once. Naming the axes converts unknown-unknowns into a checklist.

---

## 3. The pipeline and the hard-won method (the part that took the most iteration)

The pipeline is a funnel — cheap and wide first, expensive and thin last: Stage 0 formalize
(one-time, frontier) → Stage 1 enumerate (free) → Stage 2 cheap crank (batched) → Stage 3
dedup/alias screen (embeddings) → Stage 4 frontier adjudication (survivors only) → Stage 5 owner
curation. The architecture, not the spend, does the work. What follows are the lessons that the
dualization pilots and the six subsequent sweeps forced into the design — each cost real tokens to
learn and each is now load-bearing.

**3.1 The Stage-2 verdict is untrustworthy — in both directions — and the funnel must not gate on
it.** This is the single most important operational lesson. Cheap models over-produce (haiku emits
vacuous "meta-slogans" for self-application, spurious "rate-of-X" for temporalization); capable
models over-collapse (sonnet stamps genuine second-order primes "mere iteration," genuine genera
"restatement"). Neither the NEW nor the COLLAPSE verdict can be trusted alone. So the funnel gates on
three model-agnostic mechanisms instead: **step-0 alias verification** (a claimed "already in the
corpus" slug is looked up deterministically; if it doesn't exist, the candidate is a clean gap, not
a collapse — the model named a pole so obvious it assumed the catalog had it), the **articulated-
candidate rescue rule** (a COLLAPSE labelled "trivial/mere-iteration" is trusted *only* when the
model wrote no candidate; if it articulated a real structure but stamped it trivial, it goes to
Stage 4 regardless), and **Stage-4 frontier adjudication** of survivors.

**3.2 The retrieval-proximity fallacy (recurs on every "add-an-axis-to-P" operator).** When the
transformed prime is genuinely absent, the *input itself* is always the nearest corpus entry to its
own output. A model reads that proximity as evidence of restatement and blanket-zeros the find. It
first appeared in generalization (sonnet Stage-4 zeroed ~40% of real genera as "the input is the top
hit"), then reappeared as "mere iteration" (self-application), "trivial over time" (temporalization),
"trivial at larger scale" (spatialization), "trivial modal word attached" (modalization). The fix is
a standing **§D amendment** in every Stage-4 prompt: *referencing the base is exactly what a valid
transformation does; judge on the added structure, not on retrieval rank.* The discriminator is
always the operator's structure-line (LEVEL2 / DYNAMICS / EXTENT / MODAL / CRITICAL), never proximity.

**3.3 …but the §D amendment makes Stage-4 over-HOLD, so the real discriminator is convergence +
canonical name.** Once told not to reject on proximity, sonnet swings the other way and grants a HOLD
to nearly every mechanical "X-of-P" coinage. The signal that actually separates genuine primes from
coinage noise is **cross-input convergence** (how many different inputs independently reach the same
candidate) combined with the **presence of a canonical scholarly name**. Ranking Stage-4 survivors by
these two and auto-demoting the single-route, un-named coinages to "Tier-B bulk" is what keeps the
final shortlist small and real. (See 4.3 — the strongest finds are all high-convergence.)

**3.4 The protection rule (zero silent deaths).** No cheap check — including a Stage-2 self-collapse
or fixed-point verdict — may retire the last live route of a candidate that either (a) converges from
≥2 inputs/flavors or (b) is already a manifest-known hold. Single-sample cheap-model judgments are
unreliable in both directions; convergence and prior adjudication are the trustworthy cheap signals.

**3.5 Sub-agents silently drop 2–8% of payload rows and drift to single-line format.** Never trust
per-batch counts. Reconcile every sweep against the canonical 1,325-slug set, parse flexibly (accept
both multi-line and " / "-delimited blocks), keep only valid-slug rows, and re-run the missing.
Every sweep needed at least one recovery pass.

**3.6 The gate was re-based.** The original "≤5% survivor rate" target is unreachable at cheap-check
reliability and was retired. The gate is now **zero silent deaths of known-good candidates + an
acceptable Stage-4 cost-per-accepted-prime**. ~30–45% of applications reach Stage 4; that is the
accepted cost of never silently killing a real find.

---

## 4. Results

### 4.1 Per-operator ledger (unary phase)

| Op | Flavors | Apps | Tier | Fixed pts (unique already-X) | Survivors | Alias confirms | Rejects | Genuine holds → stubs | Cost |
|---|---|---|---|---|---|---|---|---|---|
| 1 dualization | 3 | 3,973 | haiku | — | — | 9 | ~1,250 | 6 accept-recs + ~25 holds | ~6.9M |
| 2 self-application | R+M (1 pass) | 1,325 | sonnet | 536 (**41%**) | 526 | 95 | 168 | ~10 strong + ~5 mod → **15** | ~1.9M |
| 3 temporalization | 3 | 3,971 | **haiku** | 1,450 → 788 (**59%**) | 1,258 | 357 | 906 | 1 strong + 4 mod → **5** | ~3.3M |
| 4 spatialization | 3 | 3,975 | sonnet | 716 → 495 (**37%**) | 1,016 | 200 | 2,043 | 3 strong + 3 mod → **6** | ~4.5M |
| 5 generalization | 1 (+ strata) | 1,326 | sonnet | — | — | ~18 | — | ~47 holds (framed = engine) | ~9.4M |
| 6 modalization | 3 | 3,975 | sonnet | 350 → 297 (**22%**) | 882 | 407 | 2,336 | 4 holds → **4** | ~4.5M |
| 7 perspective inversion | 1 (pilot only) | 53 | sonnet | 7 (pilot) | 1 | 8 | 37 | 1 gap → **1** (retired-saturated) | ~0.14M |
| 8 threshold/phase | 2 (pilot only) | 106 | sonnet | 19 (pilot) | 1 | 19 | 65 | 2 gaps → **2** (retired-saturated) | ~0.16M |
| 13 cluster | catalog-internal | 82 clusters | — | — | — | — | — | 0 new (retired-saturated) | small |
| 12 interpolation | n-ary (61 edges) | 61 | sonnet | — | 0 | — | 56 | 0 new; 13 missing-edge + 13 mis-parent flags (retired-saturated) | ~0.08M |
| 11 analogy completion | n-ary (full 1,325) | 1,325 | sonnet | — | 7 | — | 1,305 | **7 genuine (ergodicity, allostasis, coherentism, generativity, boundary_object, construal_level, +)** — the ONLY n-ary with real yield | ~1.4M |
| 10 tension-resolution | n-ary (53-sample pilot) | 53 | sonnet | — | 0 | — | 53 | 0 new (retired-saturated); resolutions = generic balance or dualization re-runs | ~0.08M |
| 14 lattice/symmetry | catalog (frontier pass) | 15 gaps | opus | — | 5 | — | — | **5 genuine cells (infinitism, cheap_talk, common_pool_resource, positional_good, type_iii_error)** — 2nd n-ary with yield | ~0.04M |
| 9 composition | n-ary (88-pair pilot) | 88 | sonnet | — | 0 | — | 88 | 0 new (retired-saturated); pairs = conjunction or already-named; 23 subsumption→edges | ~0.08M |

**THE FULL 14-OPERATOR SET IS COMPLETE (2026-07-04).** All operators 1–14 have been run to
completion or retired on saturation. 127 emergent-prime stubs accumulated for owner curation; corpus
frozen at 1,325 throughout.

Byproducts not in the table: **259 candidate DAG edges** (missing-ancestor flags from ops 5 + 13,
"the genus exists but isn't a DAG ancestor") — a densification harvest whose value rivals the prime
yield; and the retained collapses (`negatives/*.jsonl`) as hard negatives for analogical-reasoning
training.

### 4.2 The saturation gradient (an unexpected structural finding)

Each operator's fixed-point census — the primes for which "apply the operator" returns the prime
essentially unchanged — is a map of which corpus primes are *inherently* self-referential / temporal
/ spatial / modal. Read across operators, the census sizes reveal how evenly the corpus grew along
each axis:

- **Temporal — 59% already-dynamic** (feedback, half-life, Markov, diffusion, oscillation, …). The
  most-saturated axis; the corpus is deeply dynamical.
- **Self-referential — 41%** (self-application is the highest *fixed-point* operator — recursion,
  reflexivity, closure, symmetry are maximal generalizers).
- **Spatial — 37%** (gradient, network, fractal, percolation, …). Somewhat less covered.
- **Modal — 22%**, the *least*-saturated at the fixed-point level — **yet the highest alias rate
  (407)**. This is the subtle finding: the modal layer is covered not by many inherently-modal primes
  but by a *small set of unusually powerful* ones (probability, optionality, counterfactual_reasoning,
  modal_reasoning, uncertainty, risk, expected_utility, mixed_strategy) that absorb most
  modalizations as aliases. Low fixed-point saturation + high alias absorption = "few primes doing a
  lot of work."
- **Threshold/phase — observationally the most-saturated of all** (retired on a pilot: tipping_points,
  threshold, percolation, critical_mass, nucleation, hysteresis, symmetry_breaking, regime_change,
  punctuated_equilibrium all present), which is why op-8 was retired without a full sweep.

The companion doc predicted the structural core would be "nearly countable and nearly counted"; the
census gradient is the first quantitative evidence of *how* nearly, axis by axis.

### 4.3 The genus-convergence phenomenon (where the real finds live)

The strongest discoveries are never single-input surprises — they are **genera that hundreds of
inputs quietly converge on**. Spatialization's `field` was reached as "a field of P" from hundreds of
inputs; modalization's `possibility` as "the possibility space of P" from hundreds; temporalization's
`transient_response` from ~12; self-application's `second_order_preference` from 5 and `metanorm` from
4; modalization's `expected_value` from dozens. The individual "X-of-P" instances are trivial
coinage; the *convergence itself* is the signal that a genus node is missing. This is why 3.3's
discriminator works: convergence count is a near-direct readout of "how load-bearing is the gap this
candidate names."

### 4.4 The emergent-prime inventory (115 stubs, all pending owner curation)

All in `prime_abstractions/v2_density_pilot/`, each with frontmatter + Core Idea + Notes carrying
candid keep/cut guidance. By operator:

- **Dualization (~36):** incl. eager_evaluation, risk_seeking, confabulation, pareidolia,
  hold_up_problem, consequentialism (+deontology lattice gap), foundationalism, brittleness,
  common_mode_failure, negative_transfer, decision_paralysis, knightian_uncertainty, …
- **Generalization (~47):** incl. exploration_exploitation, consilience, inductive_bias,
  partial_order, law_of_large_numbers, information_discarding_projection, nested_epistemic_depth,
  referent_drift, scaling_law, stigmergy, + Tier-B coinages.
- **Self-application (15):** second_order_preference, metanorm, meta_learning, structural_stability,
  evolvability, meta_optimization, second_order_uncertainty, second_order_probability,
  recursive_theory_of_mind, kompetenz_kompetenz, metacognitive_load, meta_stereotype_threat,
  model_risk, model_uncertainty, meta_decision.
- **Temporalization (5):** transient_response, critical_slowing_down, overshoot,
  predictability_horizon, phase_synchronization.
- **Spatialization (6):** field, mean_field, continuous_relaxation, spatial_random_field,
  continuum_limit, density.
- **Modalization (4):** possibility, defeasibility, deontic_modality, expected_value.
- **Threshold (2):** catastrophe, order_parameter.
- **Perspective inversion (1):** interpellation (framed — the addressee-constituted-as-subject seat
  of grand_narrative; the lone find of an otherwise-saturated operator).

### 4.4a Reflexively-discovered prime: `interpolation` (accepted 2026-07-04)

A 129th stub, minted outside the sweep. While documenting the operators it emerged that 13 of the 14
map to existing primes (dualization↔`duality`, self-application↔`reflexivity_self_reference`,
generalization↔`abstraction`, composition↔`composition`, analogy↔`analogy`, …) but **operator 12,
interpolation, had no home prime.** Screening confirmed interpolation is genuinely absent, and its
dual `extrapolation_beyond_sampled_regime` is present — a clean dualization gap (the corpus named the
risky pole, never the safe one). Owner-accepted; stub at `v2_density_pilot/interpolation.md`. The
genus question (is the truer prime `betweenness`?) was resolved: betweenness is a *relation*,
interpolation an *inference* — different kinds of thing; interpolation accepted on its own,
`betweenness` deferred as a matter of taste (already partly embodied by `convexity`+`order`). See
insights 9 and 10 for the two methodological findings this episode produced.

A **meta-uncertainty cluster** cuts across operators and should be curated together:
second_order_uncertainty, second_order_probability, model_uncertainty, model_risk (op-2/6) all
describe uncertainty/probability/risk about one's own uncertainty apparatus and may collapse to one
genus. Similarly `expected_value` (op-6) vs the present `expected_utility` is a genus-vs-fold call,
and `overshoot`/`density`/`spatial_random_field` are likely children of `transient_response`/`field`.

---

## 5. Cross-cutting insights (the durable takeaways)

1. **Model tier is predictable from the operator's cognitive demand.** Mechanical single-axis moves
   (dualization's flip, temporalization's add-a-clock) run fine on the cheap model — pilot haiku-vs-
   sonnet agreement was 12/15 (temporalization). Moves that require holding the input *and its
   relatives* simultaneously (generalization's lift, self-application's fixed-point discrimination,
   spatialization's is-it-already-spatial, modalization's already-modal) need the capable model —
   pilot agreement dropped to 5/15 (spatialization) and 7/15 (modalization). The 15-prime haiku probe
   in each pilot is a cheap, reliable tier oracle; run it every time.

2. **The pilot doubles as a saturation check, and saturation is a legitimate stop.** Three operators
   retired on near-zero pilot yield without a full sweep: op-13 cluster (0 new), op-8 threshold
   (2 non-genuine NEW / 53; the region is the most-covered in the corpus), op-7 perspective inversion
   (1 framed NEW / 53; both seats of every canonical relational pair already named). This saved ~4M
   tokens on op-8 alone. A near-zero yield is not a failed operator — it is a completeness result
   about that region. Notably, **saturation is predictable from the corpus at build time**: for op-7
   and op-8 a five-minute grep of the relevant primes (tipping_points/threshold/… ; signaling+
   screening/principal+agent/…) told us the region was covered *before* the pilot ran — the pilot
   merely confirmed it. A cheap pre-pilot corpus check is a reliable saturation predictor.

3. **Fixed points and aliases are the product, not the waste.** For the audit-heavy operators
   (temporalization, spatialization, modalization, threshold) the *discovery* yield is small but the
   *audit* yield is large: a census of which primes are inherently temporal/spatial/modal plus
   hundreds of balanced-granularity confirmations that the corpus's existing primes are well-placed.
   These operators are completeness instruments first and discovery engines second.

4. **Every operator produces a large Tier-B coinage tail** ("rate-of-P", "field-of-P", "possibility-
   space-of-P", "meta-P"). Low keep-rate, not stubbed individually, but retained in `survivors/*.jsonl`
   — and many are latent **DAG-composition** signals (the transformed prime is P composed with an
   existing prime like feedback/field/possibility, not a new atom).

5. **The residual error is biased toward false negatives, and that is by design.** Because the
   surviving Stage-2 model over-collapses and the funnel only lets a find die at Stage 2/3 if the
   model articulated *no* candidate, the misses concentrate in low-convergence, single-route cases —
   exactly the ones least likely to be real primes. High-value genera, reached from many inputs,
   survive on any one route. The runbook's bet holds: "a missed NEW is cheap; other operators and
   later sweeps get another shot." Everything is persisted, so the miss channel is cheaply
   re-auditable without re-cranking.

6. **Cost is dominated by tier, not by scope.** A full 3-flavor haiku sweep (~3.3M) costs less than a
   single-pass sonnet operator's Stage-2 at scale; the two expensive sonnet sweeps (spatialization,
   modalization) were ~4.5M each. The architecture keeps frontier tokens on the thin survivor stream;
   the tier choice is the real cost lever.

7a. **The whole-program yield law: an operator yields only if it reaches a structural position NOT
   ALREADY IMPLIED by the corpus.** With all 14 operators run, the pattern is sharp and unifies the
   n-ary phase. The four operators that RECOMBINE or FILL-BETWEEN existing primes all saturated at ~0:
   composition (op-9, fuses two existing primes), tension-resolution (op-10, synthesizes an opposed
   pair), interpolation (op-12, fills a DAG gap), cluster (op-13, finds a missing ancestor) — because
   any prime *implied* by recombining what's already there was already surfaced reactively during
   corpus/DAG construction. Only the two operators that reach genuinely NEW positions yielded: **op-11
   (analogy completion)** reaches *diagonal / cross-domain composite* primes — reachable only by a
   two-relation functorial mapping, not one axis-step (`ergodicity`, `allostasis`, `boundary_object`,
   `construal_level`); **op-14 (lattice completion)** reaches the empty *cells* of near-complete
   symmetric families (`infinitism`, `cheap_talk`, `common_pool_resource`, `positional_good`,
   `type_iii_error`). Both clustered their finds in the FRAMED/social-science families — the same
   yield region op-05's staircase found. This is the program's central completeness result: **the
   corpus is complete with respect to axis-steps and recombination; it is incomplete only along the
   diagonals and in the empty cells of its symmetry families — exactly the two moves that a
   reactive, mining-driven construction cannot systematically reach.**

8. **Domain-general and domain-specific finds both get captured, flagged differently.** The operators
   surface genuine domain-specific abstractions too (genetic_drift, dispersion_relation, hazard_rate,
   …). Standing convention (owner, 2026-07-03): stub these as well, flagged domain-specific (lower
   substrate-independence), so curation can weigh them separately. A deferred backlog holds the
   catch-up list.

9. **Operators act on REPRESENTATIONS, not on Platonic concepts — a mis-framed prime hides the
   transforms that would reach its neighbours.** Discovered 2026-07-04 while resolving the
   `interpolation` gap (§4.4a). Interpolation is the safe half of the within-range/beyond-range
   inference distinction; its dual, `extrapolation_beyond_sampled_regime`, IS in the corpus — so
   dualization (op-01) *should* have reached interpolation, and the crank receipts show it *tried*:
   the 1a pass produced "an apparatus deployed only *within the regime* its calibration was
   established in" (interpolation's territory) and 1b a near-identical near-miss. But the dual
   crystallised as a *malfunctioning-detector* description and collapsed onto `domain_adaptation`,
   never as the clean inference "interpolation." Cause: the input prime is catalogued as a **failure
   mode** ("a calibrated apparatus blind to its own regime exit"), not as the neutral structural pole
   "inference beyond the sampled range" — so the operator flipped the *failure framing* (yielding
   "detect the failure," i.e. the already-present `out_of_distribution_detection`) rather than the
   *structural pole* (yielding interpolation). This is a limitation class distinct from the yield law:
   an operator's reach is bounded by how its inputs are represented. Two fixes: (i) a **representation-
   normalisation pass** that neutralises failure-mode / domain-specific framings to their structural
   pole *before* sweeping, and (ii) **re-running key operators after any reframing.** This does NOT
   break the completeness claim — interpolation is an *empty symmetry-family cell*, exactly the residual
   the yield law predicts; op-14 lattice is the operator that "owns" such cells and missed this one only
   because the in/out-of-range opposition was not legible in the corpus (again a representation problem,
   not a theory hole).

10. **A third discovery mode exists beyond mining and the endogenous operator search: EXOGENOUS
   REFERENCE-COVERAGE.** The move that actually found `interpolation` was none of the 14 operators — all
   of which are *endogenous* (they transform/combine primes already in the corpus, or examine its own
   graph). It was: take an authoritative **external enumeration**, map each element onto the corpus, and
   mint the elements with no image. Here the external set was *the 14 operators themselves* (the corpus
   ought to contain the primes its own method is built from) — a **reflexive** instance that is closed
   and now complete: 13 of 14 operators mapped to existing primes, interpolation was the sole gap, so
   that check is finished and yielded exactly one prime. The *general* family is open-ended (unboundedly
   many external taxonomies) and therefore does NOT share the closed-set completeness guarantee of the 14
   endogenous operators — it is a **disciplined, checkable form of mining** (bounded coverage-check
   against a fixed list), not a peer operator. This gives the program a clean trichotomy of discovery
   modes: **mining** (open, unstructured) · **endogenous operator search** (closed, self-contained, the
   14) · **exogenous reference-coverage** (semi-structured, gap-completing against external scaffolds).

---

## 6. Honest limitations

- **Curation is pending.** All 115 stubs are candidates, not accepted primes. The saturation
  stop-rule (accepted-new per 100 applications) cannot be finalized until the owner's Stage-5 pass
  produces acceptance counts; the per-operator "holds" are the pipeline's recommendation, not a
  verdict. Expect a meaningful fraction — especially the Tier-B coinages and the fold candidates — to
  be cut or merged.
- **The corpus is frozen at 1,325.** Running every operator against a static snapshot means later
  operators cannot build on earlier finds (e.g. modalization couldn't lift onto self-application's
  new second-order primes). This trades some compounding discovery for a clean, comparable saturation
  curve; a second pass after incorporation would catch the cross-operator compositions.
- **False-negative floor.** See 5.5 — the method optimizes for zero silent deaths of *known-good*
  candidates, not zero false negatives overall (which is unmeasurable). Low-convergence real primes
  can slip through.
- **Single-corpus, single-curator.** The completeness claim is relative to this corpus's current
  granularity and one curator's judgment. The reproducible templates make it re-runnable, but the
  acceptance bar is not yet inter-subjectively calibrated.

---

## 7. What remains

**ALL 14 OPERATORS ARE COMPLETE (2026-07-04).** What follows documents the (now-closed) combinatorial
tier for the record. The **unary phase** (operators 1–8 + 13) completed first; the **n-ary phase** ran
op-12, 11, 10, 14, 9 in that owner-chosen order.
The n-ary operators do NOT brute-force the pair space (1,325² ≈ 1.76M); each runs on a **pre-filtered
candidate set** computed deterministically from the DAG/archetypes/embeddings. Pre-filter sizes
(computed 2026-07-03) and status:

| Op | Pre-filter | Candidate set | Est. cost | Status |
|---|---|---|---|---|
| 12 interpolation | large-gap subsumption edges (cos<0.65) | 61 | ~0.08M | **DONE — retired saturated** (0 new; 13 missing-edge flags) |
| 11 analogy completion | operator-confirmed pairs × 4th term | ~200–500 | ~0.4–1M | next (owner order) |
| 10 tension-resolution | named tensions (`structural_tensions`, ~1,400) → opposed pairs | ~300–1,400 | ~0.6–3M | after 11 |
| 9 composition | archetype-co-occurring ∩ embedding-close | ~1,100 (cos>0.75) → ~4,000 (cos>0.7) | ~2–8M | deferred |
| 14 lattice/symmetry | natural product SPACES (not pairs) | ~dozens of spaces | ~0.2–0.5M | deferred |

Measured n-ary cost (op-12): **~1.24K tokens/application** for compact 2-prime payloads — *cheaper*
than the ~2K planning figure. The whole combinatorial phase is ~3–10M tokens, dominated by op-9/op-10,
all pilot-gated with early-retire on saturation. A confirmed prior: ops 12 and 13 were *already
exhausted reactively* during DAG construction (project-06) — op-13 returned 0 new and op-12 now
confirms 0 new; ops 9/10/11/14 are the genuinely-unturned combinatorial ground (though the corpus's
proven saturation makes modest yield the base case). **The last standing byproduct — the DAG-edge
harvest — now totals ~272 candidate edges** (op-05 247 + op-13 12 + op-12 13), a densification value
that has rivalled the prime yield throughout.
- **Owner Stage-5 curation** of the 128-stub queue (incl. the reflexively-discovered `interpolation`)
  — the bottleneck for the completeness number and for the ~295 DAG-edge harvest.
- **A publication-grade derivative** — IN PROGRESS 2026-07-04: `PAPER_operator_search.md` (the
  full-program paper, yield law as spine) + `PAPER_operator_compendium.md` (per-operator treatment) +
  this synthesis + `07_operator_prime_discovery.md` are the seed set for the public conceptual-section
  writeup.

### Open threads / to-do (added 2026-07-04, from the interpolation episode)

1. **Representation-normalisation pass** (from insight 9). Some existing primes are catalogued under
   failure-mode or domain-specific framings that hide the transforms an operator would otherwise reach
   (worked example: `extrapolation_beyond_sampled_regime` hid interpolation from dualization). Build a
   pass that detects such primes and neutralises them to their structural pole, then **re-run the key
   operators (esp. dualization and lattice-completion) against the reframed primes.** Likely to recover
   more interpolation-style gaps. Systematically uncover which primes are mis-framed first.
2. **Exogenous reference-coverage as a formal third discovery mode** (from insight 10). Add it to the
   method as a distinct family alongside mining and the endogenous operator search — explicitly flagged
   as open-ended (no closure guarantee), a disciplined coverage-check against a fixed external list.
3. **Run reference-coverage against the high-value external lists**: the mathematical-primitives list
   (order, boundary, limit, betweenness, continuity, …), the canonical cognitive-bias list, and the list
   of logical fallacies. Each is a bounded, authoritative enumeration likely to surface real gaps. This
   is a future pass, deferred (owner will circle back after the current writing).

---

## Appendix — where each thing lives on disk

| Artifact | Path |
|---|---|
| Conceptual foundation (closure, prior art, staircase) | `workspace/07_operator_prime_discovery.md` |
| Operational pipeline + 14 operators | `OPERATOR_SEARCH_RUNBOOK.md` |
| Per-operator results ledger | `workspace/operator_search/SATURATION.md` |
| Stage-0 machinery (prompts, collapse tests, few-shot) | `workspace/operator_search/templates/NN_*.md` |
| Per-operator finds + method notes | `workspace/operator_search/manifest_opNN_*.yaml`, `opNN/s4/shortlist.md` |
| Fixed-point / audit censuses | `workspace/operator_search/audit_*.jsonl` |
| Emergent prime stubs (115) | `prime_abstractions/v2_density_pilot/<slug>.md` |
| Retained collapses (training negatives) | `workspace/operator_search/negatives/*.jsonl` |
| Running chronological log | persistent memory `project_operator_search_dualization_pilot.md` |

*Extend this document after each subsequent search (op-7, then the n-ary operators): add the ledger
row (§4.1), any new census/gradient data (§4.2), new genus-convergence finds (§4.3), the stub delta
(§4.4), and any new cross-cutting insight (§5). Keep §6 limitations honest as the picture fills in.*
