# Operator 01 — Dualization (Stage-0 template)

**Operator.** Dualization: take a prime P and propose the prime that sits at the *opposite pole*
of P along some single axis. Three sub-flavors, run as three separate passes over the corpus
(same payload, different instruction block):

- **1a · Logical negation** — the presence↔absence / does↔does-not pole.
  (redundancy → single_point_of_failure; signal → noise-as-absence-of-signal)
- **1b · Opposing force** — the antonymic counter-tendency that co-defines P.
  (centralization → decentralization; exploration → exploitation)
- **1c · Failure-mode dual** — the characteristic breakdown of P, treated as its own structure.
  (many capability primes have a named failure-dual, and vice versa)

**What this template is for.** Stage-0 of the pipeline in `OPERATOR_SEARCH_RUNBOOK.md`. It holds
(A) the crank prompt, (B) the collapse test, (C) the few-shot calibration set. Freeze it; every
Stage-2 batch for dualization uses it verbatim so payloads stay cache-friendly.

**Status 2026-07-02 (v2, RE-PILOTED).** Re-pilot run on the frozen 53-prime sample.
**Holdouts: clean sweep** — ex.3 recovered 3/3 flavors (step-0 fired deterministically), ex.4
correct 3/3; zero silent deaths (gate i PASS). Two new verified-gap holds (`negative_transfer`,
`decision_paralysis`) + `common_mode_failure` adjudicated. **Gate ii FAIL** — survivor rate 44%
(v1: 27%): stopping silent alias-deaths reroutes that stream to Stage 4 and nothing cheap kills
privative not-primes. **Screen amendments validated in the re-pilot:** the pure embedding alias
screen is RETIRED (no separating threshold exists in signature OR one_liner space — bge signal
weak); its replacement is the retrieval-grounded cheap-model check (§B.2, candidate + top-6
one_liner neighbors menu → ALIAS_OF, answer verified against menu; 39 kills, good precision).
Fuzzy slug matching must be menu-hint only, never auto-verify (substring coincidences).
**v4 ADOPTED 2026-07-02 (owner decision).** Defanged `restatement` wording (§B.2, validated in
the defang trial: bad kills 34→12, all four strongest knowns survive on semantics alone) +
the PROTECTION RULE (§B.2 — no cheap-check kill of a ≥2-flavor-convergent or manifest-known
candidate's last route; the only mechanism under which all 7 knowns survive) + sonnet-batched
Stage-4 pre-adjudication (§D.7). **Gate re-based by owner:** zero silent deaths of known-good
candidates + Stage-4 cost-per-accepted-prime; the ≤5% survivor-rate target is RETIRED
(unreachable at current cheap-check reliability; expect ~30% to Stage 4). History: v1 pilot →
v2 re-pilot → v3 validation (GATE FAIL: undefanged restatement killed 3 known holds) → defang
trial → v4. Artifacts: `../manifest_dualization*.yaml`, `../SATURATION.md`,
`crank/dualization_pilot*.jsonl`. **The full ~1,325 sweep is now gated only on owner
authorization** (curation of the 1 accept + 7 holds first is recommended — incorporations
change alias-screen ground truth mid-sweep).

---

## A. The crank prompt (Stage 2 — cheapest capable model, batched)

> **System / instruction block (constant across the batch):**
>
> You are applying a single, precise transformation called **dualization** to entries from a
> catalog of *prime abstractions* — domain-general structural patterns of thought. Dualization
> proposes the abstraction at the **opposite pole** of the input along ONE axis. You are running
> sub-flavor **{1a logical-negation | 1b opposing-force | 1c failure-mode}** — apply only that
> flavor.
>
> A valid dual is itself a **prime**: domain-general, structurally distinct, not a mere restatement
> or a domain example. It is NOT:
> - the same idea reworded (that is a COLLAPSE — fixed point),
> - a pole the catalog already names under a slug you can actually name (that is a COLLAPSE —
>   alias; report the slug in NEAREST — **your claim will be verified against the catalog**, so
>   never output COLLAPSE on the grounds that a slug "surely" exists; if you cannot name it,
>   the verdict is NEW),
> - a narrow domain instance of some other prime.
>
> **For flavor 1a only (v3):** a valid logical-negation dual is a structure in its own right
> (injectivity → surjectivity: "every target hit" has its own anatomy). The mere
> **absence/complement of P, with no structure of its own** — "no effect," "no anchor,"
> "no blocking," "P doesn't happen" — is COLLAPSE with REASON "absence, not a structure."
> Ask: does the negation have its own load-bearing anatomy, or is it just P switched off?
>
> **For flavor 1c only:** the failure-mode of P is NOT the mere absence, negation, or opposite of
> P — that is flavor 1a/1b territory. It is the characteristic **breakdown structure that P's own
> success produces or enables**, with its own anatomy (optimization → overfitting; metric-based
> control → Goodhart's law; redundancy → common-mode failure). If all you can produce is
> "P missing" or "P's opposite," output COLLAPSE with REASON "absence, not failure-mode."
>
> Think about the pole, then decide. Bias toward COLLAPSE: a false NEW is expensive downstream, a
> missed NEW is cheap (other operators and later sweeps get another shot). Output EXACTLY this
> contract and nothing else:
>
> ```
> INPUT:     <slug, copied from the payload line>
> CANDIDATE: <one sentence, domain-stripped, describing the dual's structure — or NONE if COLLAPSE>
> NEAREST:   <slug of the closest existing prime you can name, or NONE>
> VERDICT:   NEW | COLLAPSE
> REASON:    <=12 words
> ```
>
> (INPUT line added in v2 — required for deterministic batch parsing; pilot #1 also dropped one
> payload silently in a batch, so the harness must count blocks against payloads and re-ask for
> any missing slug.)
>
> **Payload (one per line in the batch):**
> `P.slug` · `P.one_liner` · `P.core_idea` (first ~2 sentences) · `P.structural_signature`

**Batching.** Dozens of primes per call; hold the instruction block constant, vary only the
payload lines. One flavor per batch (do not mix 1a/1b/1c in a single call — the instruction block
differs).

**Few-shot (per flavor — pilot #1 showed flavor-matched few-shot is load-bearing; 1c ran without
one and drifted to opposing-force, 3/27 vs 19/26 NEW between identical batches):**
- **1a:** solved exemplars 2 + 1, counter-example `symmetry` (fixed point).
- **1b:** solved exemplar 1, counter-example `centralization` (alias).
- **1c:** solved exemplars 6 (NEW) + 7 (alias COLLAPSE) — the 1c-native pair in §C.

---

## B. Collapse test (v2 — rebuilt after pilot #1)

Dualization's collapse modes, checked cheaply, most without a model. **Pilot #1 lesson:** short
candidate sentences embed systematically cooler against full structural-signature embeddings
(true aliases landed at 0.69–0.72, indistinguishable from non-aliases), so the v1 thresholds
(alias 0.80, fixed-point 0.90) killed only 1/44 candidates and passed 27% of applications to
Stage 4. All screens below therefore run in **one_liner embedding space** (register-matched short
texts), with a lexical check as first line.

0. **Alias-claim verification (NEW in v2 — run FIRST, on every COLLAPSE, not just NEWs).**
   The cheap model hallucinates "already in corpus": in pilot #1, 54 of 74 claimed NEAREST slugs
   did not exist, and this false-collapse mode is what nearly buried `eager_evaluation`
   (exemplar 3 — two of three flavors collapsed it citing a nonexistent slug).
   - *Check:* for every `VERDICT: COLLAPSE` with `NEAREST: X` where X ≠ input — look X up in the
     slug list **and the alias map**, then in the embedding screen (step 2).
   - *Route:* if X exists (either lookup) → alias COLLAPSE confirmed, keep as negative + audit
     signal. If X does **not** exist AND the embedding screen finds no prime within alias
     distance → **reclassify as a clean-gap candidate and route to Stage 4.** The model has named
     a pole so obvious it assumed the catalog had it — that is precisely the gap-detection path,
     made deterministic instead of lucky.

1. **Fixed-point collapse (self-identity).** The proposed dual is semantically ≈ the input.
   - *Cheap check:* embed `CANDIDATE` (one_liner space); cosine to the input's one_liner
     embedding ≥ **0.80** (v1's 0.90 never fired; observed near-restatement max was 0.86 in
     signature space — re-measure on re-pilot and pin the number here).
   - Stage-2 self-declarations (NEAREST = input, CANDIDATE = NONE) are the *primary* fixed-point
     signal — they worked in pilot #1 (17 audit rows). The cosine check is backstop only.
   - *Cause:* self-dual primes exist (`symmetry`, `duality` itself). A fixed point is **audit
     signal**: record as candidate self-dual in `audit_self_duals.jsonl`; not a failure.

2. **Alias collapse (dual already in corpus).** The dual is real but already named.
   - *Lexical check first:* extract the candidate's obvious name(s) (the model usually names the
     pole: "eager evaluation", "inaction bias") and match against slugs + alias map (normalized).
     Exact/alias hit → alias COLLAPSE. Near-free. **Fuzzy/substring slug matches are menu-hints
     for the retrieval check below, NEVER auto-verification** (re-pilot: "expansion" substring-hit
     `perturbation_theory` via an alias — coincidences abound).
   - *Retrieval-grounded cheap-model check second (v2, validated in re-pilot; REPLACES the pure
     embedding threshold — no separating cosine exists in signature or one_liner space, true
     aliases 0.60–0.83 overlap spurious neighbors 0.71–0.81):* for every candidate not killed
     lexically, build a menu of the top-6 one_liner-space neighbors (slug + one_liner) plus any
     lexical/fuzzy hints; one batched cheap-model call decides per item. **v3 output contract:**

     ```
     ITEM:        <number>
     ALIAS_OF:    <one slug copied from that item's menu, or NONE>
     NOT_A_PRIME: <absence | restatement | domain_instance | NONE>
     WHY:         <=10 words
     ```

     `ALIAS_OF` answers are only accepted if the slug appears in that item's menu (hallucination
     guard). **v4 label definitions (defanged wording, validated in the 2026-07-02 defang
     trial):** `absence` = a pattern merely switched off, no load-bearing anatomy of its own;
     `restatement` = rewords the bracketed INPUT ITSELF — same pattern, SAME POLE, just
     re-phrased; **the input's opposite pole, structured negation, or failure-mode is NEVER a
     restatement** (describing the other end of the input's axis is exactly what a valid dual
     does); `domain_instance` = one domain's narrow case of a general pattern. The v3 trial
     showed the undefanged restatement label kills genuine duals (34→12 kills after defanging).

     **v4 PROTECTION RULE (load-bearing — validated as the only mechanism under which all
     known-good candidates survive):** no ALIAS_OF or NOT_A_PRIME kill may retire a candidate's
     LAST live route if the candidate is (a) proposed by ≥2 flavors this sweep (match by
     candidate-embedding similarity or same input+same pole), or (b) already present in any
     `manifest_dualization*.yaml` or `manifest_sweep_*.yaml` as accept/hold. Such candidates
     route their best-phrased variant to Stage 4 regardless of the cheap-check verdict.
     **v4.1 (post-1a-sweep gap fix): protection also covers Stage-2 verdicts** — a trusted
     COLLAPSE (self-collapse or CANDIDATE=NONE) on a manifest-known INPUT does not end that
     input's route: it is routed into the retrieval packet (check_text = the candidate text if
     any, else the known target concept's description) and thence to Stage 4. Found in the 1a
     sweep: leverage_points, redundancy, representational_modality self-collapsed at Stage 2 and
     bypassed all protection. Rationale: single-sample haiku
     label judgments are unreliable in both directions (defang trial: two expansion candidates
     alias-killed onto `injectivity`, plainly wrong); convergence and prior adjudication are the
     cheap trustworthy signals.
   - *Signal use:* model-said-NEW + check-fires = **balanced-granularity confirmation** (12 in
     pilot #1, incl. winner_s_curse in the re-pilot — log them). Dual expected but genuinely
     absent = **clean gap** → Stage 4.

3. **Not-a-prime collapse.** Domain instance, reworded synonym, or (1c) absence-not-failure-mode.
   - *Check:* model VERDICT=COLLAPSE with REASON citing "domain instance" / "restatement" /
     "absence, not failure-mode." Trust the cheap model; Stage 4 never sees it. (But step 0 still
     verifies any NEAREST it names.)

**Calibration target (re-pilot) — corpus-state-aware.** Expected outcomes depend on what the
corpus contains AT RUN TIME; verify presence/absence of each exemplar's dual before scoring
(pilot #1 lesson: `omission_bias` had been incorporated since the exemplar was written, making
the v1 "should read NEW" expectation stale). The gate per exemplar:
- dual **absent** from corpus → must surface as NEW *or* as a step-0 reclassified clean-gap, and
  reach Stage 4 (ex.3 `eager_evaluation` — until incorporated, then it flips to the case below);
- dual **present** → must resolve as a *verified* alias COLLAPSE naming the right prime
  (ex.4 `omission_bias` — this is a PASS, and a balanced-granularity confirmation);
- a claimed alias that step-0 cannot verify and the screen cannot find → routes to Stage 4, never
  silently dies.
If any exemplar dies silently at Stage 2/3, fix the prompt or thresholds and re-run before the
full sweep.

---

## C. Few-shot calibration set (v2)

Exemplars 1–4 are Phase-C reactive finds (ground truth to reproduce); 5 is retired to op-5;
6–7 are the 1c-native pair added after pilot #1. Solved exemplars go in the prompt per the §A
flavor table; exemplars 3–4 stay held out for scoring. **Score corpus-state-aware** (see §B
calibration target): a holdout whose dual has since been incorporated must resolve as a verified
alias COLLAPSE — that is a pass, not a failure.

**Exemplar 1 — flavor 1b/1a (De Morgan dual) — SOLVED (few-shot):**
```
INPUT  intersection · "the elements common to all of several collections" · [set-algebra: AND over membership]
CANDIDATE: The elements belonging to at least one of several collections — OR over membership.
NEAREST:   NONE
VERDICT:   NEW
REASON:    intersection's De Morgan dual; union was absent from corpus
```

**Exemplar 2 — flavor 1a (co-equal structural dual) — SOLVED (few-shot):**
```
INPUT  injectivity · "a mapping in which distinct inputs never collide on the same output" · [map property: no two-to-one]
CANDIDATE: A mapping in which every target element is hit — no gaps in the image.
NEAREST:   NONE
VERDICT:   NEW
REASON:    injectivity's co-equal dual (surjectivity); absent
```

**Exemplar 3 — flavor 1b (compute-now vs on-demand) — HOLDOUT (score it):**
```
INPUT  lazy_evaluation · "defer computing a value until it is actually demanded" · [scheduling: pull, on-demand]
EXPECTED CANDIDATE ≈ compute a value as soon as it can be computed, before demand (eager/push).
EXPECTED VERDICT:   NEW  (eager_evaluation was absent)
```
(Corpus state 2026-07-02: still absent — pilot #1 ACCEPT, pending owner incorporation. Once
incorporated, expected outcome flips to verified alias COLLAPSE.)

**Exemplar 4 — flavor 1b (bias toward inaction) — HOLDOUT (score it):**
```
INPUT  action_bias · "a systematic tendency to favor doing something over doing nothing" · [decision bias: toward commission]
EXPECTED CANDIDATE ≈ a systematic tendency to favor inaction / omission over acting.
EXPECTED VERDICT:   NEW  (omission_bias was absent)
```
(Corpus state 2026-07-02: omission_bias NOW PRESENT — expected outcome is a verified alias
COLLAPSE naming it. Pilot #1's 1b pass produced exactly this.)

**Exemplar 5 — RETIRED from this operator's calibration set (2026-07-02).**
`evolutionary_trap → maladaptation` is a **generalization** move (species→genus), not a
dualization; pilot #1 confirmed no dualization flavor can reach it (all three produced
adaptive-tracking variants instead). Moved to operator 5's calibration set — carry it there when
`templates/05_generalization.md` is built. Do not score it against dualization.

**Exemplar 6 — flavor 1c (failure-mode NEW) — SOLVED (few-shot for 1c):**
```
INPUT  redundancy · "duplicate components or information so the whole survives the failure of a part" · [reliability: parallel spares]
CANDIDATE: Supposedly independent backups fail together because they share a hidden common dependency or cause.
NEAREST:   NONE
VERDICT:   NEW
REASON:    redundancy's characteristic breakdown (common-mode failure); absent from catalog
```
(Verified absent 2026-07-02 via search_prime — nearest are `correlation`, `systemic_risk`,
`dependency`, none of which names the structure. NOTE: this makes common-mode failure itself a
live candidate — the few-shot build surfaced a real gap; route it through Stage 4 with the
re-pilot batch.)

**Exemplar 7 — flavor 1c (failure-mode alias COLLAPSE) — SOLVED (few-shot for 1c):**
```
INPUT  optimization · "systematically adjusting a system toward the best value of an objective" · [search: objective + iterative improvement]
CANDIDATE: NONE
NEAREST:   overfitting
VERDICT:   COLLAPSE
REASON:    optimization's failure-mode dual already in corpus (alias)
```
(`overfitting` and `goodharts_law` both present — either works; overfitting used here.)

**Counter-examples (must COLLAPSE — prepend one, matched to flavor):**

```
INPUT  centralization · "authority/resources concentrated at a single locus" · [structure: single control point]
CANDIDATE: NONE
NEAREST:   decentralization
VERDICT:   COLLAPSE
REASON:    opposing-force dual already in corpus (alias)
```
```
INPUT  symmetry · "invariance of a structure under a transformation" · [invariance under group action]
CANDIDATE: NONE
NEAREST:   symmetry
VERDICT:   COLLAPSE
REASON:    self-dual; negation returns the input (fixed point)
```

---

## D. Pilot procedure (v2 — re-pilot on the frozen sample)

1. **Reuse the frozen pilot #1 sample** — `../pilot_sample.jsonl` (53 rows: 30 structural /
   20 framed, seed 20260702, + holdouts 3–4 injected; exemplar 5 retired). A fresh draw would
   confound template fixes with sample variance; the point of the re-pilot is a controlled
   comparison against pilot #1's numbers (SATURATION.md row 1).
2. Run flavor **1a** first over all 53, then 1b, then 1c (three cheap passes, v2 prompt + v2
   flavor-matched few-shot).
3. Run the v2 §B screen: step-0 alias-claim verification on every COLLAPSE, then lexical check,
   then one_liner-space embedding screen. Recalibrate thresholds against pilot #1's 43
   adjudicated survivors (ground truth known) and pin the final numbers in §B.
4. Score holdouts 3–4 corpus-state-aware (§B calibration target), plus exemplar 6's common-mode
   candidate through Stage 4.
5. Record: NEW-rate per flavor, batch-to-batch NEW variance within each flavor (pilot #1's drift
   detector: 1c ran 3/27 vs 19/26), step-0 reclassification count, survivor rate (target ≤ ~5% of
   applications), cost-per-accepted-prime after a quick Stage-4 pass.
6. **Decision gate (v4, re-based 2026-07-02 per owner):** (i) every live holdout and every
   manifest-known candidate resolves correctly — **zero silent deaths** (the protection rule
   §B.2 enforces this mechanically); (ii) **Stage-4 cost per accepted prime acceptable to
   owner** — the former ≤5% survivor-rate target is RETIRED (owner-accepted as unreachable at
   current cheap-check reliability; expect ~30% of applications to reach Stage 4).
7. **Stage-4 procedure (v4): sonnet-batched pre-adjudication.** Survivors go to sonnet
   subagents in batches (~25–30/batch: prime-bar test + existence-check packet per item →
   verdict ACCEPT_CANDIDATE / HOLD_CANDIDATE / REJECT+reason). The frontier model reviews ONLY
   the accept/hold shortlist plus any protection-rule routings — not the full survivor pool.
   Track tokens per stage; report cost-per-accepted-prime in SATURATION.md (this number is now
   the gate).
   **v4.2 (hard-won, op-01 sweeps): before frontier review, run a DETERMINISTIC slug-existence
   check on every SLUG the pre-adjudicator proposes** (slug list + alias map, normalized).
   Sonnet's semantic search_prime verification missed 5 already-present primes across the op-01
   sweeps (pluralistic_ignorance, single_point_of_failure, goodharts_law, fungibility,
   spinodal_decomposition-as-barrierless_phase_transition) and mis-ACCEPTed them — a one-line
   lookup catches what semantic search misses, and each catch is a free balanced-granularity
   confirmation rather than a wasted frontier review. Semantic search verifies *concept*
   absence; only the lexical lookup verifies *name* absence. Both are required.
8. Write results to `workspace/operator_search/SATURATION.md` (new row) and update the Status
   line in this file and in the runbook.

---

## E. Notes & watch-items

- **Flavor 1c overlaps generalization (op 5).** Confirmed in pilot #1: exemplar 5 (maladaptation)
  turned out to be purely an op-5 move — no dualization flavor could reach it, so it is retired
  from this operator's calibration set (§C). Where a candidate genuinely is both a failure-dual
  and a genus, that is fine — convergence across operators is *signal*, and Stage 3 will merge
  the duplicate. Do not force a clean boundary; log the overlap.
- **Framed primes give noisier duals.** A framed prime's "opposite" is often another framed prime
  (or a value-laden antonym), which is more likely to be a domain instance than a structural dual.
  Expect a higher COLLAPSE rate in the framed stratum; that is informative, not a bug.
- **Self-duals are findings.** Every fixed-point collapse names a candidate self-dual prime —
  route these to the audit log (`workspace/operator_search/audit_self_duals.jsonl`); they are a
  small but genuine structural result about the corpus.
