# Operator-Driven Prime Discovery — Concepts, Foundations, and What Is Genuinely New

**Purpose.** A think-piece for the owner (not a runbook): the conceptual foundation for
discovering prime abstractions by applying a closed set of *operators* to the existing corpus,
and an honest account of which parts are prior art and which are genuinely new territory. The
operational procedure lives in the companion `OPERATOR_SEARCH_RUNBOOK.md`.

**Status 2026-07-01.** Framing doc, first pass. Written after recognizing that Phase-C
emergent-prime work (`workspace/phase_c_outputs/_emergent_new_primes.yaml`) was already
operator-driven discovery done *reactively*. This doc argues the case for doing it *proactively*.

---

## 1. The core reframe: discovery as search over concept-space

The encyclopedia has, until now, grown by two motions: **mining** (send an LLM into the
literature of a domain, harvest what people have already named) and **reactive derivation**
(during DAG construction, notice that a needed parent/sibling is missing and draft it). Both are
valuable and both are *opportunistic* — they surface a prime only when something external
(a text, a graph hole) points at it.

The reframe is this: **treat prime discovery as a graph search.** The states are primes. The
moves are operators — deterministic transformations that take a prime (or a small tuple of them)
and propose a new one. The visited-set is your existing corpus plus its alias map. Discovery is
then *node expansion*: apply the move-set to the frontier, screen the outputs against the
visited-set, keep what is genuinely new, repeat.

This is not a metaphor decorating the old process; it changes what is possible. Three things
follow from it that the mining/reactive process cannot give you:

1. **A move-set makes the search enumerable.** If the operators are a closed set and the corpus
   is finite, then "apply every operator to every prime" is a finite, checkable job — not an
   open-ended hunt. You can say what you have and have not tried.
2. **A visited-set makes novelty decidable (cheaply).** You already built the alias/similarity
   machinery. In search terms it is the closed-list: it tells you whether an expanded node is new
   without a human looking. That is what lets the crank run mostly unattended.
3. **A move-set makes a completeness claim possible.** You cannot argue "the corpus is near-complete"
   from mining — you never know what you didn't read. But you *can* argue it from search: if every
   operator, run to saturation, stops yielding new accepted primes, the reachable space is
   substantially covered. Completeness becomes a property you measure rather than assert.

The reason this is feasible *now* and was not before is worth stating plainly, because it is the
crux of the novelty argument (§4). Graph search needs two things: a frontier to expand and a
function that expands a node. You now have a large, typed, embedded frontier (the corpus) and,
for the first time in history, a **semantic node-expander**: an LLM can actually execute the
instruction "apply temporalization to *equilibrium*" and return a coherent candidate. Neither
existed at the scale required until very recently.

---

## 2. Why these operators, and why the set is plausibly closed

An operator moves a structure along **one axis of variation**. The claim that the set is complete
rests on enumerating the axes a structure can move along, not on brainstorming transformations.
A single structure can be moved along: its **polarity** (dualization), its position in **time**
(temporalization), its **scale/extent** (spatialization), its level of **abstraction**
(generalization/specialization), its **modal status** (modalization), the **viewpoint** it is
read from (perspective inversion), its **linearity** (threshold/phase), and its relation to
**itself** (self-application). Structures can be *combined* by conjunction (composition),
opposition (tension-resolution), proportion (analogy completion), and infilling (interpolation).
And a *collection* of structures reveals absences in exactly two ways: a missing ancestor
(cluster-without-parent) and a missing lattice cell (gap/symmetry completion).

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. (Dualization, for instance, has three sub-flavors that
hit different targets: logical negation, opposing-force, and failure-mode. They are worth running
separately, but they are one operator because they move along one axis: polarity.)

The deep reason this matters: **an axis you never sweep is a systematic blind spot, not a random
one.** Mining misses primes at random (whatever you happened not to read). An unswept operator
misses primes *structurally* — every temporal variant of every static prime, all at once. The
value of naming the axes is that it converts unknown-unknowns into a checklist of
known-unknowns.

---

## 3. What your own corpus reveals about the operators

The Phase-C emergent list is, in retrospect, an operator-application log — and reading it that
way tells us which operators are high-yield and which you have never run.

**Operators you have already run, reactively:**

- *Generalization (finding the genus)* — heavily. `stochastic_process` as the genus of
  markov/random-walk/brownian; `calibrated_rule_vs_moving_world` as the genus of
  concept-drift/data-drift; `coercion` as the parent of compellence+deterrence;
  `natural_selection` as the variation→selection→retention engine behind a dozen children. This
  is your single most productive operator to date, and it was run *only* when a DAG hole forced it.
- *Dualization* — opportunistically, by eye. `surjectivity` ("injectivity's co-equal dual is
  absent"), `union` ("intersection's De Morgan dual"), `eager_evaluation` ("lazy_evaluation's
  structural dual"), `omission_bias` ("action_bias's mirror sibling"), `maladaptation`
  ("evolutionary_trap's general contrast"). Every one of these was found because a human noticed
  an asymmetry. A systematic dualization sweep would have *predicted* all five up front, before
  any DAG work, and would have caught the ones nobody happened to notice.
- *Interpolation / cluster-without-parent* — this is essentially what Phase-C blind DAG
  construction *is*: the "18 abstractions repeatedly needed as the missing parent/sibling" are
  interpolation and missing-ancestor outputs. You have effectively already validated operators
  12 and 13 — you just ran them as a side effect of a different job.

**Operators there is no evidence you have ever run:**

- *Temporalization, spatialization, modalization, perspective inversion, threshold/phase.* These
  are the cheap unary sweeps, and they target the primes least likely to surface from mining
  (nobody writes a paper titled "the temporal version of X"). This is the clearest patch of
  unturned ground in the whole project.
- *Analogy completion (A:B :: C:?)* as a deliberate generator — you have the pieces (operator-related
  prime pairs) but have not extrapolated fourth terms systematically.

So the honest picture is: your best-yielding operators have been running *reactively and
incompletely*, and roughly half the operator set has never been run at all. The program is not
"try a speculative new idea"; it is "finish, and make exhaustive, a process you have already
proven works — and open the axes you have not touched."

---

## 4. What is prior art, and what is genuinely new

Intellectual honesty first: **none of the individual operators is original.** They have deep
pedigrees, and it strengthens the project to acknowledge this, because it means each operator is
a *battle-tested* move rather than a guess.

- **Pólya** (*How to Solve It*, 1945) names *generalization, specialization,* and *analogy* as the
  core heuristics of mathematical discovery. Three of your operators are literally Pólya's list.
- **Category theory** gives dualization its rigorous form (the opposite category; every theorem
  has a dual for free), gives analogy-completion its form (a functor is a structure-preserving
  map — exactly the arXiv 2602.01992 formalization), and gives self-application its home (monads,
  fixed points).
- **Formal Concept Analysis** (Wille, 1982) already computes the *complete* lattice of concepts
  from an object–attribute table and surfaces implied concepts that no one named — this is your
  operators 13 and 14 (cluster-without-parent, lattice-gap) with a fifty-year-old algorithm
  behind them. It is prior art you can *borrow machinery from*, not just cite.
- **TRIZ** (Altshuller) has "trends of engineering-system evolution" (segmentation,
  transition to micro-level, increasing dynamism) that are recognizably temporalization,
  spatialization, and granularization — applied to *machines*.
- **Conceptual blending** (Fauconnier & Turner) is composition; **Hegelian dialectic** is
  tension-resolution; **Mendeleev's** predicted-element gaps are the periodic-table precedent for
  lattice/symmetry completion; **Gärdenfors' conceptual spaces** underwrite the
  spatialization/interpolation intuition and the embedding approach.

The novelty is therefore **not in any operator.** It is in five things, and this is the part worth
being clear-eyed about because it is what a skeptical reader (or a paper reviewer) will probe:

1. **The target.** Every prior tradition applies its moves to a *bounded* domain: Pólya to
   mathematics, TRIZ to engineering, FCA to a fixed attribute table, blending to linguistic
   meaning. Applying a unified operator set to **domain-general cognitive primitives spanning all
   fields at once** is, as far as I can find, undone. TRIZ is the closest sibling, and it is
   explicitly confined to physical/engineering contradictions. You are proposing TRIZ's ambition
   at the level of *abstraction itself*.

2. **Proactive exhaustiveness over a curated frontier.** The prior traditions use their moves
   *reactively*, to solve a problem in hand. Running the full move-set over an entire existing
   corpus as a *census* — expanding every node deliberately rather than when a problem points at
   it — is a different activity. It is the difference between using a chess move and enumerating a
   game tree. Your own Phase-C work is the reactive version; nobody (including you, yet) has run
   the proactive version.

3. **The stack that makes it economical.** The search is only feasible because three capabilities
   coincide: a large *typed* corpus (the frontier), *structural embeddings + an alias screen* (the
   cheap visited-set test), and an *LLM semantic operator-executor* (the node expander). Remove any
   one and the crank stalls — no frontier, no cheap novelty test, or no way to actually apply an
   operator at scale. This coincidence is a few years old at most.

4. **A measurable completeness claim.** Because the move-set is closed and the corpus finite, you
   can run each operator *to saturation* and report the accumulation curve. "We ran the eight
   unary operators over all 1,170 primes; six saturated below a 2%-novel threshold; the corpus is
   estimated N% complete under this move-set" is a claim no mining-based catalog can make. This is
   a genuine methodological contribution independent of any prime it discovers.

5. **Discovery and training-data generation are the same pass.** The operator crank's *failures*
   — the fixed-point collapses and the alias-rejections — are precisely the
   structurally-tempting-but-wrong candidates you want as hard negatives for teaching analogical
   reasoning. No prior discovery method produces its own contrastive training set as a byproduct,
   because no prior method was coupled to a corpus with a structural-similarity metric. This ties
   the discovery program directly to the synthetic-data thesis (arXiv 2602.01992: data
   composition, not scale, drives analogical reasoning) and roughly doubles the return on tokens
   spent.

If you wanted the one-sentence version for a paper abstract: *prior work supplies the moves and
one-domain applications; the contribution is a closed operator set over a cross-domain prime
corpus, run as a saturating proactive search, made economical by the embedding/alias/LLM stack,
and yielding its own analogical-reasoning negatives.*

---

## 5. The asymmetry that should shape strategy

Structural and framed primes live in different kinds of space, and the operator program should
treat them differently — this is the most actionable insight in this doc.

**Structural primes approximate a *closed* space.** They are the combinatorics of a small
vocabulary (entities, relations, feedback, thresholds, flows, symmetries, boundaries). Operators
permute a finite alphabet, so the reachable set is bounded and you can genuinely approach a
*census*. My prior would be that you are already past 90% here; the remaining finds will feel
either exotic or like intermediates between things you hold. For the structural core, the
operators are a **completeness instrument**.

**Framed primes are an *open* space.** New institutional and technological domains keep minting
new frames (platform economics, ML training dynamics, mechanism-design-for-crypto). Enumerating
more framed children is endless and low-value — you would be chasing a moving frontier forever.

The strategic consequence: **on framed primes, the high-value operator is generalization / cluster-without-parent, because it moves mass from the open set into the closed core.** Every time you take a cluster of framed primes with no common ancestor and successfully name their structural parent, you have made a *permanent* addition to the bounded core and simultaneously organized an unbounded number of potential framed children under it. That is a compounding return. Enumerating framed children is a treadmill; lifting them to structural parents is a staircase. The program should be biased hard toward the lift.

This also reframes the "how many primes are out there" question from the previous discussion. The
right answer is not a single number but two: the structural core is *nearly countable and nearly
counted*; the framed layer is *uncountable in principle and only ever current-complete*. The
operator program's job is to finish the census of the first and to keep lifting the second into
the first.

---

## 6. Collapse is signal, not waste

A last conceptual point that changes how the crank should feel to run. Most operator applications
will "fail" — self-application returns a fixed point, dualization returns something already in the
corpus, generalization returns a parent you already have. It is tempting to treat these as wasted
tokens. They are not; they are **audit output**:

- A self-application **fixed point** is evidence the input prime is maximally general — a "top"
  element of its region. That is a structural fact about the corpus worth recording.
- A dualization that lands on an **existing** prime is a *consistency check*: it confirms your
  granularity is coherent (the pair is present and balanced). A dualization that lands on
  *nothing* is a clean gap. Either way the operator has told you something true about the corpus.
- An alias-collision is a **negative training example** (see §4.5) and also a nudge that two
  corpus entries may be closer than their separate existence implies — occasionally surfacing a
  merge you should have made.

So the operators are simultaneously a discovery engine, a corpus-audit, and a
negative-example generator. The same crank serves all three, and the "failures" of the first are
the outputs of the second and third. Budget accordingly: a low novel-yield operator is not a
failed operator if its collapses are feeding the audit and the training set.

---

## 7. Where this leaves the token budget

The economics follow directly from §1 and §6. Because novelty is decidable cheaply (the
embedding/alias visited-set) and because most expansions collapse, the expensive resource —
frontier-model adjudication — should touch only the thin stream that survives the cheap filters.
The runbook builds this as a funnel: deterministic enumeration (free) → cheap-model crank
(pennies, heavily batched) → embedding dedup/alias screen (near-free) → frontier adjudication
(expensive, ~1–5% of candidates) → owner curation. Run over months, one operator at a time, in
expected-value order (dualization and the framed-prime lift first), each to its own saturation.
The point of the whole design is that a small, steady token budget is sufficient because the
architecture — not the spend — is doing the work.

---

*Companion: `OPERATOR_SEARCH_RUNBOOK.md` (the operational procedure, operator templates, collapse
tests, and staged pipeline). Related project docs: `06_learnability_and_curriculum.md`,
`workspace/phase_c_outputs/_emergent_new_primes.yaml` (the reactive precursor to this program).*
