# Operator 03 — Temporalization (Stage-0 template)

**Operator.** Temporalization: take a prime P (typically static/structural) and **add a time axis**,
proposing the prime that is P's genuinely *dynamic* counterpart. Three sub-flavors, run as three
separate passes over the corpus (same payload, different instruction block):

- **3a · level→flow** — a stock / quantity / level becomes its **rate / flow** (the derivative).
  (a quantity held → the rate at which it changes; balance → throughput)
- **3b · state→trajectory** — a static configuration / resting state becomes the **path, transient,
  or history** of getting there. (equilibrium → the relaxation/approach dynamics; a distribution →
  its evolution over time; a structure → its formation)
- **3c · present→anticipation** — a present-focused prime becomes its **forward-looking /
  expectation / planning** version. (preference → intertemporal/time preference; decision →
  planning; value → expected future value)

The characteristic non-result is the **already-temporal fixed point** (P is *already* dynamic, so
adding a time axis returns P — feedback, half_life, markov_process, diffusion, oscillation). Like
op-02's fixed points these are *audit signal* (they map which corpus primes are inherently
temporal), not merely failures — persist them (§E, `audit_temporalization.jsonl`).

**What this template is for.** Stage-0 of the pipeline in `OPERATOR_SEARCH_RUNBOOK.md`: (A) the
crank prompt, (B) the collapse test, (C) the few-shot calibration set, (D) the pilot procedure,
(E) notes. Freeze §A; every Stage-2 batch uses it verbatim so payloads stay cache-friendly. It
inherits the op-01 v4.2 / op-02 v1.1 machinery wholesale (step-0 alias verification, retrieval-
grounded cheap check, protection rule, deterministic slug check, INPUT-line contract +
block-count reconciliation, articulated-candidate rescue) and adds one operator-specific device:
the **DYNAMICS rule** (§A), the temporalization analog of op-02's LEVEL2 rule.

**Model tier (to be confirmed by pilot).** Temporalization is a mechanical single-axis move (like
dualization's polarity flip, which ran on haiku at Stage 2), so haiku *may* suffice — BUT the two
collapse judgments (is P already temporal? does the output add genuine dynamic structure or is it
trivial "P over time"?) are the risk, and op-02/op-05 showed cheap models fail such judgments. So
the pilot runs **sonnet Stage 2 + a 15-prime haiku floor probe** and picks the cheaper model that
clears the gate for the full sweep. Per the op-02 keystone, the Stage-2 verdict is advisory in any
case — the funnel gates on step-0 + articulated-candidate rescue + Stage-4, not on Stage-2 NEW.

**Status 2026-07-03 (v1 — BUILT, pilot pending).** Template authored. Calibration anchors verified
against the frozen 1,325 corpus: `equilibrium` PRESENT but its dynamic counterparts
(transient/relaxation/trajectory/momentum) ABSENT; `flow` PRESENT; `time_preference_discounting_future`
PRESENT (present→anticipation alias); `half_life`/`markov_process`/`diffusion`/`oscillation`/
`stationarity`/`hysteresis` PRESENT (already-temporal fixed points). Pilot next (§D).

---

## A. The crank prompt (Stage 2 — cheapest capable model, batched; pilot decides haiku vs sonnet)

> You are applying a single, precise transformation called **TEMPORALIZATION** to entries from a
> catalog of "prime abstractions" — domain-general structural patterns of thought. Temporalization
> **adds a time axis** to a (usually static) prime and asks whether that produces a *distinct*,
> genuinely **dynamic** prime. You are running sub-flavor
> **{3a level→flow | 3b state→trajectory | 3c present→anticipation}** — apply only that flavor.
>
> - **3a (level→flow):** turn a stock/quantity/level into its RATE/FLOW — the thing per unit time,
>   the derivative. (an amount held → the rate it changes; a balance → the throughput)
> - **3b (state→trajectory):** turn a static configuration or resting state into the PATH,
>   TRANSIENT, or HISTORY of reaching it. (equilibrium → the approach/relaxation dynamics; a fixed
>   distribution → its evolution; a finished structure → its formation process)
> - **3c (present→anticipation):** turn a present-focused prime into its FORWARD-LOOKING version —
>   expectation, forecast, planning, anticipation. (preference → time/intertemporal preference; a
>   present choice → planning over future choices)
>
> A valid temporalization output is itself a **prime**: domain-general, structurally distinct, with
> its own dynamic anatomy. It is NOT:
> - an **already-temporal fixed point** — P is *already* dynamic, so adding time returns P
>   unchanged (a half-life is already a rate; a Markov process is already an evolution; feedback,
>   diffusion, oscillation are already temporal). Output `VERDICT: FIXED_POINT`. This is a real,
>   useful result (it flags P as inherently dynamic), NOT a failure — report it honestly rather
>   than inventing a fake dynamic version.
> - **trivial "P over time"** — the same static pattern merely observed for a while, with no new
>   dynamic structure (no rate, lag, transient, trajectory shape, path-dependence, or anticipation).
>   (COLLAPSE — trivial_time.)
> - a dynamic prime the catalog already names under a slug you can actually name (COLLAPSE — alias;
>   report the slug in NEAREST — your claim WILL BE VERIFIED, so never collapse on the grounds that
>   a slug "surely exists"; if you cannot name a specific slug, the verdict is NEW).
> - a narrow domain instance.
>
> **DYNAMICS RULE (load-bearing — the temporalization analog of a sibling test): a genuine dynamic
> prime must exhibit at least one TEMPORAL structure that the static input LACKS** — a rate, a lag/
> delay, a transient/settling, a trajectory shape, path-dependence/hysteresis, convergence/
> divergence, an anticipation/expectation, or an accumulation. Name it concretely in the TEMPORAL
> line. If the only thing you can say is "P, but over time," there is no new structure: output
> COLLAPSE with REASON "trivial — P over time" (or FIXED_POINT if P is already dynamic). Worked
> contrast: *equilibrium → relaxation dynamics* is NEW because the approach has structure the
> resting point lacks (a transient, a rate of return, possible overshoot); *half_life → half_life*
> is FIXED_POINT because a half-life is already a rate over time.
>
> Think about the time axis and the dynamic structure, then decide. Bias toward COLLAPSE/
> FIXED_POINT: a false NEW is expensive downstream, a missed NEW is cheap (later sweeps get another
> shot). For EACH input below, output EXACTLY this contract and nothing else:
>
> ```
> INPUT:     <slug, copied from the payload line>
> CANDIDATE: <one sentence, domain-stripped, describing the dynamic prime — or NONE>
> TEMPORAL:  <the time structure present in the output but absent in the static input — or NONE>
> NEAREST:   <slug of the closest existing prime you can name, or NONE>
> VERDICT:   NEW | FIXED_POINT | COLLAPSE
> REASON:    <=12 words>
> ```
>
> **Payload:** `P.slug` · `P.one_liner` · `P.core_idea` (~2 sentences) · `P.structural_signature`

**Batching.** ~25–44 payloads/batch, INPUT-line contract, hold the instruction block constant, one
flavor per batch. Harness counts output blocks against payload lines and re-asks any missing slug
(op-01 lesson: sub-agents silently drop 2–8% of rows). Stage-2 instruction: do NOT use tools/search
— every claim is verified downstream.

**Few-shot (per flavor):**
- **3a:** solved exemplar A (level→flow NEW) + counter-example `half_life` (FIXED_POINT).
- **3b:** solved exemplar B (equilibrium→relaxation, NEW) + counter-example `markov_process` (FIXED_POINT).
- **3c:** solved exemplar C (preference→time_preference, alias COLLAPSE) + the trivial counter-example.

---

## B. Collapse test (inherits op-01 v4.2 / op-02 v1.1 machinery; temporalization specifics noted)

0. **Alias-claim verification (run FIRST, on every COLLAPSE/NEW naming a NEAREST).** Look the
   claimed NEAREST up in the slug list + alias map (normalized), then the one_liner embedding
   screen. Exists → alias COLLAPSE confirmed (keep as negative + balanced-granularity signal). Does
   NOT exist AND no prime within alias distance → **reclassify as clean-gap → Stage 4** (the model
   named a dynamic pole so obvious it assumed the catalog had it). Fuzzy/substring matches are
   menu-hints only.

1. **Already-temporal fixed-point collapse — OPERATOR-CHARACTERISTIC, retained as audit signal.**
   `VERDICT: FIXED_POINT` → append a row to `workspace/operator_search/audit_temporalization.jsonl`
   with `{input, operator: "03_temporalization", flavor, source: "stage2_verdict", reason}`. These
   map which corpus primes are inherently dynamic (feedback, half_life, markov_process, diffusion,
   oscillation, random_walk, momentum-like, relaxation-like). Never routed to Stage 4.

2. **Alias collapse (dynamic version already in corpus).** Handle exactly as op-02 §B.2: lexical
   check first (the model usually names the dynamic pole), then the **retrieval-grounded cheap-model
   check** — candidate + top-6 one_liner-space neighbors menu → `ALIAS_OF` (must be copied from the
   menu) / `NOT_A_PRIME`. **Defanged labels, op-03 wording:**
   - `trivial_time` = "P over time" with no new dynamic structure (op-03's analog of op-02's
     `mere_iteration`).
   - `domain_instance` = one field's narrow dynamic case of a general pattern.
   - **A genuine dynamic prime whose static base is the nearest corpus entry is NOT `trivial_time`
     just because it references its base** — describing the dynamics of P's own quantity is exactly
     what a valid temporalization does; the discriminator is the TEMPORAL line, not retrieval
     proximity (op-05 §D / op-02 §D amendment — inherited).

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

3. **Protection rule (v4/v4.1).** No `ALIAS_OF`/`NOT_A_PRIME` kill (and no Stage-2 self-collapse or
   FIXED_POINT) may retire a candidate's LAST live route if the candidate is (a) proposed by ≥2
   flavors/inputs this sweep (convergence), or (b) already present in any `manifest_*` as accept/hold.

4. **Articulated-candidate rescue rule (v1.1 — the op-02 keystone, carried forward).** Trust a
   COLLAPSE labelled `trivial_time` ONLY when `CANDIDATE: NONE` AND `TEMPORAL: NONE`. If the model
   wrote a SUBSTANTIVE `CANDIDATE` (named a real dynamic structure) but stamped `trivial_time`,
   route it to Stage 4 regardless — the new-vs-trivial call is a frontier judgment and the
   discriminator is the TEMPORAL line. `FIXED_POINT` with `CANDIDATE: NONE` stays a fixed point.

5. **Deterministic slug-existence check (v4.2)** on every SLUG the Stage-4 pre-adjudicator proposes
   (slug list + alias map, normalized) BEFORE frontier review. Semantic search verifies *concept*
   absence; only the lexical lookup verifies *name* absence — both required.

**Calibration target (pilot, corpus-state-aware). Zero silent deaths.**
- `equilibrium` (3b) → dynamic counterpart (relaxation/transient/approach) verified ABSENT → must
  surface NEW or step-0 clean-gap, reach Stage 4.
- `preference` (3c) → `time_preference_discounting_future` PRESENT → must resolve as a *verified*
  alias COLLAPSE naming it (a PASS + balanced-granularity confirmation).
- `half_life`, `markov_process`, `diffusion`, `oscillation`, `stationarity` → must land FIXED_POINT
  (audit rows), NOT be forced into fake dynamic primes.

---

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

Solved exemplars go in the §A prompt per flavor; holdouts stay held out for scoring. Score
corpus-state-aware.

**Exemplar A — flavor 3a (level→flow), NEW — SOLVED (few-shot):**
```
INPUT:     accumulation-like static quantity (illustrative)
CANDIDATE: The rate at which a held quantity changes per unit time — the flow that fills or drains a stock.
TEMPORAL:  a derivative/rate (per-unit-time) absent from the static level, with its own units and sign
NEAREST:   flow
VERDICT:   COLLAPSE
REASON:    level→flow, but `flow` already names the rate (alias) — balanced-granularity confirmation
```
(Note: this doubles as an alias demonstration — `flow` is present; a level with NO named flow would be NEW.)

**Exemplar B — flavor 3b (state→trajectory), NEW — SOLVED (few-shot):**
```
INPUT:     equilibrium · "a state where opposing influences balance and the system stops changing" · [balance of forces → rest]
CANDIDATE: The transient path by which a disturbed system returns toward (or departs from) its balance point — the approach dynamics.
TEMPORAL:  a settling transient with a rate, possible overshoot, and a relaxation time — absent from the resting state itself
NEAREST:   NONE
VERDICT:   NEW
REASON:    relaxation/approach dynamics; equilibrium's trajectory counterpart is absent
```

**Exemplar C — flavor 3c (present→anticipation), alias COLLAPSE — SOLVED (few-shot):**
```
INPUT:     preference · "an ordering over options that guides present choice" · [ranking + choice-guidance]
CANDIDATE: NONE
TEMPORAL:  NONE
NEAREST:   time_preference_discounting_future
VERDICT:   COLLAPSE
REASON:    preference's forward-looking version already in corpus (intertemporal/time preference) — alias
```

**Exemplar D — FIXED_POINT (already temporal) — SOLVED (few-shot; use flavor-matched):**
```
INPUT:     half_life · "the constant time for an exponentially-decaying quantity to fall to half" · [first-order decay rate]
CANDIDATE: NONE
TEMPORAL:  NONE
NEAREST:   half_life
VERDICT:   FIXED_POINT
REASON:    a half-life is already a rate over time — adding a time axis returns it
```

**Exemplar E — trivial_time COLLAPSE (counter-example) — SOLVED (few-shot):**
```
INPUT:     symmetry · "invariance of a structure under a transformation" · [invariance under group action]
CANDIDATE: NONE
TEMPORAL:  NONE
NEAREST:   NONE
VERDICT:   COLLAPSE
REASON:    "symmetry over time" adds no dynamic structure — trivial, not a new prime
```

**Holdout — flavor 3b — SCORE IT (NOT in prompt):**
```
INPUT:     distribution / distributional_assumption (illustrative static→evolving)
EXPECTED ≈ a probability distribution that evolves over time — a stochastic/random process.
EXPECTED VERDICT: verified alias COLLAPSE if `stochastic_process` present, else NEW/clean-gap
(check corpus state at run time).
```

---

## D. Pilot procedure (v1)

1. **Sample.** Frozen `../pilot_sample.jsonl` (53 rows). It already contains many temporalization-
   relevant statics: equilibrium-adjacent, distribution, markov_process (fixed-point check),
   half_life (fixed-point check), stationarity, coupling, closure, discreteness.
2. **Stage 2 on sonnet** (3 flavors × the sample, §A prompt verbatim + flavor-matched few-shot). Run
   a **15-prime haiku probe** on 3a in parallel — the tier-decision datapoint.
3. **Stage 3–4 with the §B machinery:** step-0 alias verification → lexical → retrieval-grounded
   cheap check (defanged labels) → protection rule (incl. Stage-2 self-collapses/FIXED_POINTs) →
   articulated-candidate rescue → deterministic slug check → sonnet Stage-4 → frontier shortlist.
4. **Fixed-point handling:** every FIXED_POINT → audit row (§B.1). Report the count (op-03 is
   expected to have a substantial already-temporal population, though less than op-02).
5. **Score holdouts + calibration targets corpus-state-aware** (§B). Record: NEW/FIXED_POINT rates,
   flavor split, batch variance, step-0 reclassification count, survivor rate, cost-per-hold, and
   the haiku-vs-sonnet delta on the probe (the tier decision).
6. **Decision gate (inherits op-01 v4):** (i) zero silent deaths of live holdouts + manifest-known
   candidates; (ii) Stage-4 cost-per-accepted-prime acceptable. The ≤5% survivor target is retired.
7. On gate pass, choose the sweep model (haiku if the probe matches sonnet's fixed-point/trivial
   discrimination; else sonnet) and run the full 1,325 sweep (payloads = `../worklist_dualization.jsonl`,
   re-tagged `operator: 03_temporalization`). Corpus frozen 1,325; finds accumulate as
   manifest rows + `v2_density_pilot` stubs for end-of-search curation.

**§D AMENDMENT (mandatory for op-03 Stage 4 — inherited).** When the dynamic counterpart is absent,
the static input is ALWAYS the nearest corpus entry to its own dynamic version — so "the input is
the top search hit" is NOT evidence of trivial_time. The discriminator is the TEMPORAL line: is
there dynamic structure (rate/lag/transient/trajectory/anticipation) the static input lacks? State
this in the Stage-4 prompt or sonnet blanket-zeros genuine finds (op-05 lost ~40% of real holds to
this fallacy before the frontier override).

---

## E. Notes & watch-items

- **Fixed points are audit signal, not failure.** Op-03's fixed points map the corpus's inherently-
  temporal primes (feedback, half_life, markov_process, diffusion, oscillation, random_walk, ...).
  Persist to `audit_temporalization.jsonl`. Expect fewer than op-02 (self-application is the
  highest-fixed-point operator) but a real population — the corpus already holds many dynamic primes.
- **Overlap with modalization (op 6) and threshold (op 8).** deterministic→stochastic (a temporal-
  ization of a static relation into an evolving one) borders op-6's deterministic→stochastic
  sub-flavor; gradual→tipping borders op-8. Convergence across operators is *signal*; Stage 3 merges
  duplicates. Log the overlap; don't force a clean boundary.
- **Flavor profile expectation.** 3b (state→trajectory) likely carries the most discovery signal
  (static structures whose dynamics the corpus never named); 3a (level→flow) high alias/confirmation
  rate (flow/rate primes often already present); 3c (present→anticipation) medium — many present
  primes have a named intertemporal counterpart (time_preference), others do not.
- **Framed primes give noisier temporalizations** (as every operator): a framed prime's "dynamic
  version" is often another framed instance. Expect higher COLLAPSE in the framed stratum.
- **Second op-02 keystone carries over:** at Stage 4, rank survivors by cross-input/flavor
  convergence + canonical-name presence; auto-Tier-B the single-route un-named coinages.
