f_Emit — Field Emission Primitive

# ─────────────────────────────────────────────────────────────────────────────
# SESSION CONTEXT
# ─────────────────────────────────────────────────────────────────────────────
session_id:       "SES-20260813-EMIT-001"
date:             "2026-08-13"
author:           "umaywant2"
status:           "canonical"
version:          "1.0.0"
canonical_tag:    "[FFF:GRAVITY:EMIT]"
module:           "FFF_Gravity"
file:             "docs/FFF_Gravity/f_Emit.md"
wave:             3
node:             "F_freq"
inverse_of:       "f_Dampen"
depends_on:
  - "f_Field.md → canonical (SES-20260813-FIELD-001)"
  - "OPERATORS.md → canonical (SES-20260813-OPS-001)"
operators_introduced:
  - "F_emit"
  - "ρ(Φ)_delta"
  - "r_emit"
  - "E_emit"
primitives_introduced:
  - "PRIM:015 emit_field"
  - "PRIM:016 compute_emit_cost"
  - "PRIM:017 check_emit_ceiling"
failure_modes_introduced:
  - "FM-010 (Amplify Runaway)"
state_flags_introduced:
  - "EMIT_ACTIVE"
  - "EMIT_SATURATED"
  - "EMIT_CEILING_APPROACHED"
commit_convention: "feat(FFF_Gravity): add canonical f_Emit.md — F_freq emission primitive, F_emit/r_emit/E_emit operators, PRIM:015-017, FM-010 [SES-20260813-EMIT-001]"

[FFF:GRAVITY:EMIT] · Wave 3 · F_freq Node · Canonical v1.0.0
Engineering primitive that increases local field density ρ(Φ).
Inverse of: f_Dampen. Upper bound: ρ(Φ) ≤ 1.0 (saturation ceiling).
Sustained overuse risk: FM-010 (Amplify Runaway).

§0 — Session Context#

§0.1 — Scope of This Session#

This session establishes f_Emit as the canonical F_freq engineering primitive responsible for increasing local field density ρ(Φ). The file:

1. Defines the F_emit operator formula and all subsidiary operators (ρ(Φ)_delta, r_emit, E_emit).
2. Specifies the two Emit Conditions (EC-1, EC-2) governing safe emission.
3. Defines FM-010 (Amplify Runaway) — the failure mode triggered by emission against a saturated field.
4. Introduces PRIM:015 (emit_field), PRIM:016 (compute_emit_cost), and PRIM:017 (check_emit_ceiling).
5. Provides four worked canonical examples covering recovery, expansion, cold-start, and saturation scenarios.

§0.2 — Dependency Status at Session Open#

All dependencies satisfied. No blockers.

§1 — Module Identity#

§1.1 — Identity Block#

Tag:        [FFF:GRAVITY:EMIT]
Signature:  f_Emit(A, Φ, δρ, r_emit) → Φ_updated | FM-010
Node:       F_freq (Frequency / Coherence Node)
Role:       Engineering primitive — increases ρ(Φ)
Inverse:    f_Dampen (decreases ρ(Φ))
Layer:      Layer 1 (F_freq), engineering interface
Scope:      Bounded spatial region [0, r_emit] centered on A
Ceiling:    ρ(Φ) ≤ 1.0 — hard saturation cap (INV-003 consequence)

§1.2 — Triadic Position Diagram#

                    ┌─────────────────────┐
                    │      F_freq          │
                    │  Coherence Well      │
                    │                      │
                    │  ρ(Φ) ∈ [0, 1]      │
                    │    ↑                 │
                    │  f_Emit → +δρ        │  ← THIS FILE
                    │  f_Dampen → −δρ      │
                    │  f_Amplify → ×k_amp  │
                    └────────┬────────────┘
                             │
              ┌──────────────┼──────────────┐
              │                             │
   ┌──────────┴──────────┐       ┌──────────┴──────────┐
   │       F_fluid        │       │       F_force        │
   │   Mass-Density       │       │   Gradient/Pressure  │
   │   M_A, M_E           │       │   v_approach         │
   └─────────────────────┘       └─────────────────────┘

   G = F_freq · F_fluid · F_force  [INV-001]

f_Emit acts exclusively on F_freq. It modifies ρ(Φ), which cascades into:

• F_fluid via β = M_E × ρ(Φ) / M_A (binding ratio sensitivity)
• F_force via v_escape(A) = √(2 × M_A × ρ(Φ) / r_capture) (escape velocity rise)
• F_frame via capacity_MAX = floor(M_A × ρ(Φ) × k_frame) (frame capacity expansion)

§1.3 — What f_Emit IS and IS NOT#

§2 — Canonical Description#

§2.1 — What Emission Means#

In the FFF_Gravity framework, the coherence well defined by ρ(Φ) determines the depth of a gravitational relationship. A deeper well (higher ρ(Φ)) means:

• Higher escape velocity v_escape(A) — captured entities require more energy to leave
• Higher binding ratio β — captures are more firmly locked
• Higher frame capacity — the attractor can hold more simultaneous relationships
• Greater resonance stability — orbital mechanics are better sustained

f_Emit is the mechanism by which an attractor A actively deepens its coherence well. It does not alter the identity of A (M_A does not change), does not alter the entity E (M_E does not change), and does not alter any captured relationship's r_capture. It exclusively modifies the field state Φ, increasing ρ(Φ) by a realized delta ρ(Φ)_delta within a bounded spatial radius r_emit.

Emission is an energy-consuming operation. The cost E_emit is computed before execution. If the cost cannot be met, emission should not proceed (the caller is responsible for cost validation — see PRIM:016).

§2.2 — Saturation Ceiling#

The hard upper bound ρ(Φ) ≤ 1.0 is a module invariant (consequence of INV-003 and INV-001). A field at ρ(Φ) = 1.0 is called saturated. In a saturated field:

• All captured entities have maximum binding (β values are at their ρ(Φ)-driven peak)
• Escape velocity is at its maximum for the current M_A and r_capture
• Frame capacity is at its maximum for the current M_A and k_frame
• FM-010 (Amplify Runaway) fires on any attempt to emit into a saturated field

The ceiling is not a soft limit. check_emit_ceiling (PRIM:017) must be called before every emit_field invocation. If it returns False (no headroom), emission must be blocked.

§2.3 — Emission Decay Over Time#

Emission is not permanent by default. Unless the field state Φ is structurally supported (e.g., by an f_Amplify call that locks the increased ρ(Φ)), the elevated ρ(Φ) undergoes natural decay at the rate governed by f_Decay. This means:

• A single f_Emit call produces a transient density pulse unless sustained
• Sustained emission (repeated f_Emit calls or a paired f_Amplify lock) is required for permanent ρ(Φ) elevation
• FM-010 risk is highest during sustained emission loops — each call must pass check_emit_ceiling

§2.4 — Spatial Locality#

The r_emit parameter defines the emission radius — a spherical (or field-appropriate) region centered on A within which the ρ(Φ) increase is applied. Critically:

• r_emit must be > 0 (point emission is undefined)
• r_emit must be ≤ r_capture (emission cannot reach beyond the capture boundary — EC-2)
• Emission does not propagate beyond r_emit; entities outside the radius experience no immediate ρ(Φ) change

§2.5 — Relationship to Other F_freq Operators#

§3 — Triadic Equation#

§3.1 — Formal Signature#

f_Emit(A, Φ, δρ, r_emit) → Φ_updated | FM-010

§3.2 — Post-Conditions (from f_Field.md §7.1, extended)#

Post-condition 1:  ρ(Φ_updated) = min(ρ(Φ_current) + δρ, 1.0)
Post-condition 2:  Ψ(A)_updated > Ψ(A)_prior  [coherence signature increases]
Post-condition 3:  v_escape(A)_updated ≥ v_escape(A)_prior
Post-condition 4:  capacity_MAX_updated ≥ capacity_MAX_prior
Post-condition 5:  If ρ(Φ_current) = 0 before call, FM-002 flag is cleared on success

Post-condition 5 makes f_Emit the canonical FM-002 recovery mechanism (consistent with f_Field.md §6, which defines FM-002 as: emit_field with any δρ > 0 restores ρ(Φ) > 0).

§3.3 — G-Equation Role#

The triadic product is:

G = F_freq · F_fluid · F_force          [INV-001]

f_Emit modifies the F_freq factor in G by increasing ρ(Φ). Because ρ(Φ) appears in:

• v_escape(A) = √(2 × M_A × ρ(Φ) / r_capture) — the SC-1 threshold
• β = M_E × ρ(Φ) / M_A — the SC-4 binding floor
• capacity_MAX = floor(M_A × ρ(Φ) × k_frame) — the SC-5 frame threshold

a successful f_Emit call tightens all three active stability conditions simultaneously, making the overall gravitational system more capture-ready and binding-stable. This is why f_Emit is the primary remediation tool in the FM-004 recovery pathway.

§4 — Operator Registry#

Authority: OPERATORS.md is the symbol authority for all operators (INV-009). Definitions here are normative for f_Emit.md and must be reflected in OPERATORS.md §2.2 (previously frozen as 🔵 pending this file).

§4.1 — New Operators Introduced#

F_emit — Emission Field Strength#

F_emit(Φ, δρ, r_emit) = (δρ · k_emit) / (r_emit · (1 − ρ(Φ)))

Interpretation: F_emit measures emission efficiency — how much field-density increase is achieved per unit radius, normalized by available headroom. As ρ(Φ) → 1.0, headroom shrinks and F_emit → ∞, signaling that each marginal emission increment is increasingly costly and increasingly risky (FM-010 boundary).

Undefined when: ρ(Φ) = 1.0 (division by zero — EC-1 violation, FM-010 fires before this is evaluated).

ρ(Φ)_delta — Realized Density Increment#

ρ(Φ)_delta = min(δρ_requested, 1.0 − ρ(Φ)_current)

Note: Clipping δρ_requested to the ceiling is not an FM-010 trigger. FM-010 fires only when ρ(Φ)_current = 1.0 and emission is attempted (zero headroom). Partial emission (clipped to available headroom) is valid and produces a Φ_updated with ρ(Φ) = 1.0.

r_emit — Emission Radius#

r_emit ∈ (0, r_capture]

r_emit scales the energy cost E_emit quadratically (see below). Larger emission radii cost more energy but affect a wider region of the field state, making them more effective for F_frame capacity expansion and multi-entity stabilization scenarios.

E_emit — Emission Energy Cost#

E_emit = M_A · ρ(Φ)_delta · r_emit² · k_cost

Interpretation: Emission energy cost scales with attractor mass (larger attractors require more energy to deepen their field), with the realized density increment (larger increases cost more), and quadratically with emission radius (wider coverage is disproportionately expensive). This quadratic radius scaling discourages wasteful large-radius emissions and reflects the volumetric nature of field coverage.

When ρ(Φ)_delta = 0: E_emit = 0 — no energy is consumed (ceiling was already at maximum, but EC-1 was violated before this is reached, so this case is informational only).

§4.2 — Inherited Operators (No Changes)#

The following operators are used by f_Emit as defined in their authority files. No modifications are introduced here.

§5 — Emit Conditions#

Two conditions govern safe emission. Both must hold before emit_field executes. Violation of either blocks emission and requires the caller to handle the failure state.

§5.1 — EC-1: Headroom Bound#

EC-1:  ρ(Φ)_current < 1.0

Statement: The current field density must have at least some headroom below the saturation ceiling before emission can proceed.

Note: EC-1 evaluates the current ρ(Φ) before any delta is applied. If EC-1 is satisfied but the requested δρ would push ρ(Φ) above 1.0, the delta is clipped to the available headroom (ρ(Φ)_delta = 1.0 − ρ(Φ)_current). This is not an EC-1 violation — the clip is handled transparently by PRIM:017 before emission executes.

§5.2 — EC-2: Radius Bound#

EC-2:  0 < r_emit ≤ r_capture

Statement: The emission radius must be positive and must not exceed the attractor's established capture radius.

Rationale: Emission beyond r_capture would attempt to deepen a coherence well in a region where no captured relationship exists. Because the FFF_Gravity model is relational (field state Φ is defined relative to A and its captures), extending emission past r_capture has undefined semantics. EC-2 enforces the spatial boundary of the operator's authority.

§5.3 — Conditions as Conjunctive Gate#

EC-1 AND EC-2 must both hold. There is no partial emission that bypasses either condition. The evaluation order is:

1. check_emit_ceiling(Φ)          → EC-1 check (PRIM:017)
2. validate r_emit ∈ (0, r_capture]  → EC-2 check (inline in PRIM:015)
3. compute ρ(Φ)_delta (clip if needed)
4. compute E_emit (PRIM:016)
5. execute field density update
6. update Φ post-conditions (Ψ, v_escape, capacity_MAX references)

§6 — Failure Modes#

§6.1 — FM-010: Amplify Runaway#

FM-010:  Amplify Runaway
Trigger: EC-1 violated — emit_field called when ρ(Φ) = 1.0
State flag set: EMIT_SATURATED
Severity: Warning (blocking — emission stops, existing captures unaffected)
Recovery: f_Dampen (reduce ρ(Φ) below 1.0, then resume emission if needed)

Mechanism: When ρ(Φ) = 1.0, the coherence well is at maximum depth. The binding ratio β of all captured entities is at its field-density-driven maximum. Attempting to emit further has no legitimate physical effect — the field cannot deepen further. In the FFF_Gravity model, this represents a runaway amplification attempt: the caller is pushing emission into a field that has nowhere to go.

The consequence is not catastrophic in the sense of f_Collapse (no entities are lost, no states are destroyed), but it is a hard block:

• emit_field returns FM-010 immediately
• No ρ(Φ) change occurs
• No E_emit is charged (zero-cost failure)
• EMIT_SATURATED flag is set on Φ
• All active captures remain stable

Why the name "Amplify Runaway": In a real system using f_Amplify after f_Emit (the common sustained-emission pattern), FM-010 signals that the amplification loop has driven ρ(Φ) to 1.0 and must be paused. Without FM-010 detection, a naive amplification loop would spin indefinitely trying to push ρ(Φ) past its ceiling. FM-010 is the guard rail.

§6.1.1 — Detection Code#

def detect_fm010(phi: FieldState) -> bool:
    """
    Detect FM-010 (Amplify Runaway) condition.
 
    FM-010 fires when emission is attempted against a saturated field.
    This function checks the pre-condition; call before emit_field.
 
    Args:
        phi: Current field state.
 
    Returns:
        True if FM-010 condition is active (ρ(Φ) = 1.0), False if safe to emit.
    """
    return phi.rho >= 1.0

§6.1.2 — Recovery Code#

def recover_fm010(
    attractor: Attractor,
    phi: FieldState,
    target_rho: float,
    r_dampen: float
) -> FieldState:
    """
    FM-010 recovery via f_Dampen.
 
    Reduces ρ(Φ) from saturation to a target below 1.0 so that
    emission can resume. The target_rho should leave meaningful
    headroom (recommended: target_rho ≤ 0.90).
 
    Args:
        attractor:   The saturated attractor.
        phi:         Current saturated field state (rho = 1.0).
        target_rho:  Desired post-dampen field density (0.0 < target < 1.0).
        r_dampen:    Dampening radius (see f_Dampen.md for constraints).
 
    Returns:
        Updated FieldState with rho = target_rho and EMIT_SATURATED cleared.
 
    Raises:
        ValueError: If target_rho >= 1.0 or target_rho <= 0.0.
        RuntimeError: If f_Dampen fails (see f_Dampen.md for its own failure modes).
    """
    if not (0.0 < target_rho < 1.0):
        raise ValueError(
            f"FM-010 recovery target_rho must be in (0, 1); got {target_rho}"
        )
 
    delta_dampen = phi.rho - target_rho  # amount to reduce
 
    # Delegate to f_Dampen (canonical — see f_Dampen.md)
    phi_recovered = f_dampen(attractor, phi, delta_rho=delta_dampen, r_dampen=r_dampen)
 
    # Clear EMIT_SATURATED flag
    phi_recovered.flags.discard("EMIT_SATURATED")
    phi_recovered.flags.discard("EMIT_CEILING_APPROACHED")
 
    return phi_recovered

§6.1.3 — EMIT_CEILING_APPROACHED — Early Warning Flag#

Before FM-010 fires, the state flag EMIT_CEILING_APPROACHED is set when:

ρ(Φ) ≥ α_ceiling_warn  (default: α_ceiling_warn = 0.90)

This is an advisory flag — it does not block emission, but it signals to the caller that the field is within 10% of saturation (by default) and FM-010 is approaching. Automated emission loops should monitor for this flag and either:

• Pause emission and allow natural decay to restore headroom, or
• Invoke f_Dampen proactively to maintain a working range

§6.2 — FM-002 Recovery via f_Emit#

f_Emit is the primary recovery mechanism for FM-002 (Zero Field / Field Collapse), as established in f_Field.md §6 and f_Decay.md §6.1.3.

FM-002 recovery condition:  emit_field called with any δρ > 0 when ρ(Φ) = 0
FM-002 recovery result:     ρ(Φ) = δρ > 0 → FM-002 flag cleared
Note: EC-1 is satisfied when ρ(Φ) = 0 (0 < 1.0), so FM-002 recovery is always allowed

This means f_Emit and FM-002 have a special relationship: FM-002 is never a barrier to calling emit_field. A field at ρ(Φ) = 0 has maximum headroom (1.0), satisfies EC-1, and is the most cost-efficient state to emit into (E_emit is lowest per unit delta when ρ(Φ) is low).

§6.3 — FM-004 Recovery via f_Emit#

f_Emit is the primary recovery mechanism for FM-004 (Resonance Drift — Warn), as established in f_Decay.md §6.1.3 (recovery pathway A):

FM-004 recovery pathway A:
  1. detect FM-004 (d_bind < d_warn, δ < 0)
  2. invoke f_Emit with δρ = recovery_delta > 0
  3. increased ρ(Φ) → increased v_escape(A) → tighter binding → d_bind rises next cycle
  4. if d_bind rises above d_warn: FM-004 cleared, RESONANCE_STABLE restored

Note that f_Emit addresses the root cause of FM-004 (field weakening), not just the symptom. This distinguishes it from a patch: a successful f_Emit in FM-004 recovery produces a genuinely deepened coherence well, not a superficial state flag reset.

§7 — Engineering Primitives#

All primitives follow the established FFF_Gravity conventions:

• Pure functions (no side effects beyond return value) are tagged [PURE]
• Impure functions (modify FieldState, trigger side effects) are tagged [IMPURE]
• All type hints are illustrative (implementation-language-agnostic)
• Full docstrings are normative — they constitute the primitive's specification

§7.1 — PRIM:015 — emit_field [IMPURE]#

def emit_field(
    attractor: Attractor,
    phi: FieldState,
    delta_rho: float,
    r_emit: float,
    k_emit: float = 1.0,
    k_cost: float = 1.0
) -> FieldState:
    """
    PRIM:015 — emit_field [IMPURE]
    ==============================
    Canonical F_freq emission primitive. Increases the local field density
    ρ(Φ) of the attractor A by delta_rho (clipped to available headroom) within
    the spatial radius r_emit.
 
    This is the canonical implementation of the emit_field contract established
    in f_Field.md §7.1. PRIM:015 extends that contract with full condition
    checking, cost computation, post-condition enforcement, and FM-010 handling.
 
    Evaluation order (per INV-008):
        1. EC-1 check via check_emit_ceiling (FM-010 if violated)
        2. EC-2 check (r_emit bounds)
        3. Compute ρ(Φ)_delta (clip to headroom)
        4. Compute E_emit via compute_emit_cost
        5. Update ρ(Φ) in phi
        6. Update Ψ(A), v_escape(A) references
        7. Set/clear state flags
        8. Return Φ_updated
 
    Args:
        attractor:   The attractor whose field is being deepened.
        phi:         Current field state (contains rho, flags, coherence data).
        delta_rho:   Requested density increment. Must be > 0.
        r_emit:      Emission radius. Must satisfy 0 < r_emit ≤ r_capture.
        k_emit:      Emission coupling constant (default 1.0). See §4.1.
        k_cost:      Emission cost scalar (default 1.0). See §4.1.
 
    Returns:
        FieldState: Updated field state with:
            - rho increased by realized ρ(Φ)_delta
            - Ψ(A) updated (coherence signature risen)
            - v_escape updated (derived, not stored — recomputed on access)
            - capacity_MAX updated (derived, not stored — recomputed on access)
            - Flags updated (EMIT_ACTIVE set; EMIT_SATURATED cleared if was set)
            - EMIT_CEILING_APPROACHED set if rho_new ≥ α_ceiling_warn
 
    Raises:
        FM010Error:    EC-1 violated — ρ(Φ)_current = 1.0 (no headroom).
        ValueError:    delta_rho ≤ 0 or r_emit violates EC-2.
        RuntimeError:  phi is in a terminal state (CAPTURE_COLLISION or COLLAPSED).
 
    Side effects:
        - Modifies phi.rho, phi.coherence_signature, phi.flags in place
          (caller receives updated reference).
        - Logs emission event to GravityGraph audit trail.
        - Emits EMIT_COMPLETE event to registered observers.
 
    Cost:
        E_emit = M_A · ρ(Φ)_delta · r_emit² · k_cost
        (Computed but not deducted here — caller is responsible for energy accounting.)
        Call compute_emit_cost (PRIM:016) beforehand if pre-validation is required.
    """
    # ── Guard: terminal states ──────────────────────────────────────────────
    if phi.flags & {"CAPTURE_COLLISION", "COLLAPSED"}:
        raise RuntimeError(
            "emit_field called on terminal field state — emission is not permitted "
            "after CAPTURE_COLLISION or COLLAPSED. (INV-006: terminal states irreversible)"
        )
 
    # ── Guard: delta_rho must be positive ──────────────────────────────────
    if delta_rho <= 0:
        raise ValueError(f"delta_rho must be > 0; got {delta_rho}")
 
    # ── EC-1: Headroom Bound ────────────────────────────────────────────────
    ceiling_ok, headroom = check_emit_ceiling(phi)
    if not ceiling_ok:
        phi.flags.add("EMIT_SATURATED")
        raise FM010Error(
            "FM-010 (Amplify Runaway): emit_field called on saturated field "
            f"(ρ(Φ) = {phi.rho:.4f}). Invoke f_Dampen to restore headroom before "
            "resuming emission."
        )
 
    # ── EC-2: Radius Bound ─────────────────────────────────────────────────
    if r_emit <= 0:
        raise ValueError(f"r_emit must be > 0; got {r_emit}")
    if r_emit > attractor.r_capture:
        raise ValueError(
            f"r_emit ({r_emit}) exceeds r_capture ({attractor.r_capture}). "
            "EC-2 violated — emission radius cannot exceed capture boundary."
        )
 
    # ── Compute realized delta (clip to headroom) ──────────────────────────
    rho_delta_realized = min(delta_rho, headroom)
 
    # ── Compute emission cost (informational — energy deduction is caller's) ─
    e_emit = compute_emit_cost(
        m_a=attractor.mass,
        rho_delta=rho_delta_realized,
        r_emit=r_emit,
        k_cost=k_cost
    )
    phi.last_emit_cost = e_emit  # record for caller inspection
 
    # ── Apply density increment ────────────────────────────────────────────
    rho_prior = phi.rho
    phi.rho = rho_prior + rho_delta_realized  # always ≤ 1.0 by construction
    phi.rho = min(phi.rho, 1.0)               # defensive clamp
 
    # ── Update coherence signature Ψ(A) ───────────────────────────────────
    phi.coherence_signature = _compute_coherence_signature(attractor, phi)
 
    # ── Update state flags ─────────────────────────────────────────────────
    phi.flags.discard("EMIT_SATURATED")       # clear stale saturation flag
    phi.flags.add("EMIT_ACTIVE")
 
    # Early-warning ceiling approach flag
    ALPHA_CEILING_WARN: float = 0.90
    if phi.rho >= ALPHA_CEILING_WARN:
        phi.flags.add("EMIT_CEILING_APPROACHED")
    else:
        phi.flags.discard("EMIT_CEILING_APPROACHED")
 
    # FM-002 flag clear (ρ(Φ) > 0 guaranteed here)
    phi.flags.discard("FIELD_COLLAPSED")      # FM-002 state flag
 
    # ── Notify GravityGraph ────────────────────────────────────────────────
    _notify_gravity_graph(
        event="EMIT_COMPLETE",
        attractor=attractor,
        rho_prior=rho_prior,
        rho_new=phi.rho,
        rho_delta=rho_delta_realized,
        r_emit=r_emit,
        e_emit=e_emit
    )
 
    return phi

§7.2 — PRIM:016 — compute_emit_cost [PURE]#

def compute_emit_cost(
    m_a: float,
    rho_delta: float,
    r_emit: float,
    k_cost: float = 1.0
) -> float:
    """
    PRIM:016 — compute_emit_cost [PURE]
    ====================================
    Compute the energy cost of a prospective emission operation before execution.
 
    This pure function enables callers to pre-validate cost before calling
    emit_field (PRIM:015). It implements the E_emit formula:
 
        E_emit = M_A · ρ(Φ)_delta · r_emit² · k_cost
 
    Args:
        m_a:       Attractor mass-density M_A. Must be > 0.
        rho_delta: Realized density increment ρ(Φ)_delta (already clipped
                   to headroom by the caller or by check_emit_ceiling).
                   Must be ≥ 0.
        r_emit:    Emission radius. Must be > 0.
        k_cost:    Emission cost scalar (default 1.0).
 
    Returns:
        float: E_emit — the energy cost of the emission. Non-negative.
               Returns 0.0 when rho_delta = 0 (no-op emission).
 
    Raises:
        ValueError: If m_a ≤ 0, r_emit ≤ 0, k_cost ≤ 0, or rho_delta < 0.
 
    Notes:
        - This function is pure: it has no side effects and does not modify any state.
        - The caller is responsible for energy deduction (E_emit is returned, not spent).
        - The quadratic r_emit² term reflects volumetric field coverage cost.
        - At fixed δρ and r_emit, cost scales linearly with M_A: more massive
          attractors require proportionally more energy to deepen their field.
    """
    if m_a <= 0:
        raise ValueError(f"m_a must be > 0; got {m_a}")
    if r_emit <= 0:
        raise ValueError(f"r_emit must be > 0; got {r_emit}")
    if k_cost <= 0:
        raise ValueError(f"k_cost must be > 0; got {k_cost}")
    if rho_delta < 0:
        raise ValueError(f"rho_delta must be ≥ 0; got {rho_delta}")
 
    return m_a * rho_delta * (r_emit ** 2) * k_cost

§7.3 — PRIM:017 — check_emit_ceiling [PURE]#

def check_emit_ceiling(
    phi: FieldState,
    alpha_warn: float = 0.90
) -> tuple[bool, float]:
    """
    PRIM:017 — check_emit_ceiling [PURE]
    =====================================
    Check whether emission is safe (EC-1) and compute available headroom.
 
    This is the canonical EC-1 gate. It must be called at the start of every
    emit_field invocation. The function:
      1. Returns False (blocked) if ρ(Φ) = 1.0 (FM-010 condition).
      2. Returns True (safe) with headroom if ρ(Φ) < 1.0.
      3. Notes proximity to ceiling via the second return value.
 
    Args:
        phi:        Current field state.
        alpha_warn: Ceiling approach threshold (default 0.90).
                    When phi.rho ≥ alpha_warn, headroom is considered
                    "low" and the caller should plan dampening.
 
    Returns:
        Tuple[bool, float]:
            - bool:  True if emission is permitted (EC-1 satisfied),
                     False if FM-010 applies (ρ(Φ) = 1.0).
            - float: Available headroom = 1.0 − ρ(Φ)_current.
                     0.0 when EC-1 is violated.
 
    Raises:
        ValueError: If phi.rho < 0 (invalid field state — invariant violation).
 
    Notes:
        - Pure function: reads phi.rho only, no mutations.
        - Headroom < (1.0 − alpha_warn) signals EMIT_CEILING_APPROACHED territory.
        - Callers should treat headroom < 0.05 as requiring f_Dampen before
          any further emission cycle to prevent FM-010 on the next call.
 
    Examples:
        >>> check_emit_ceiling(phi_with_rho_0_7)
        (True, 0.30)
 
        >>> check_emit_ceiling(phi_with_rho_1_0)
        (False, 0.0)
 
        >>> check_emit_ceiling(phi_with_rho_0_95)
        (True, 0.05)  # EMIT_CEILING_APPROACHED territory
    """
    if phi.rho < 0:
        raise ValueError(
            f"Invalid field state: phi.rho = {phi.rho} < 0. "
            "Module invariant violation (INV-003 consequence)."
        )
 
    if phi.rho >= 1.0:
        return False, 0.0
 
    headroom = 1.0 - phi.rho
    return True, headroom

§8 — Canonical Examples#

§8.1 — Example 1: FM-004 Recovery via Emergency Emission#

Scenario: A captured satellite is in FM-004 (Resonance Drift — Warn). The field density has decayed to ρ(Φ) = 0.28, below the d_warn threshold. f_Decay has issued a warn flag. f_Emit is called to restore field coherence before decay reaches d_collapse.

Initial Parameters:

Emission Parameters:

Post-Emission State:

Trace:

[FM-004 detected] d_bind = 3.94, d_warn = 3.76 → WARN threshold crossed
[EC-1 check] ρ(Φ) = 0.28 < 1.0 → headroom = 0.72 ✅
[EC-2 check] r_emit = 10.0 ≤ r_capture = 12.4 ✅
[compute_emit_cost] E_emit = 5.97 × 0.35 × 100 = 208.95
[emit_field] ρ(Φ): 0.28 → 0.63
[flags] FM_WARN_ACTIVE cleared | EMIT_ACTIVE set
[next decay cycle] d_bind rises (ρ(Φ) deepened) → RESONANCE_STABLE on track

Outcome: FM-004 recovery initiated. If field holds at ρ(Φ) ≥ 0.63 for the next decay cycle, d_bind crosses back above d_warn and FM-004 is cleared.

§8.2 — Example 2: Frame Capacity Expansion via Targeted Emission#

Scenario: An attractor A has reached its frame capacity (capacity_MAX = 3, all slots filled). A new capture candidate arrives (entity E_4). Rather than calling f_Collapse or discarding E_4, the operator calls f_Emit to increase ρ(Φ), which indirectly expands capacity_MAX.

Initial Parameters:

(Note: k_frame = 0.833 gives capacity = 2 for this M_A/ρ(Φ) combination.)

Goal: Raise capacity_MAX to 3 to accommodate E_4. Need: floor(M_A × ρ(Φ)_new × k_frame) ≥ 3.

Required ρ(Φ)_new: 3 / (8.00 × 0.833) = 3 / 6.664 = 0.450... → need ρ(Φ) > 0.450 strictly.

Minimum viable ρ(Φ)_delta = 0.001 above current 0.45 → let's use δρ = 0.05 for safe margin.

Emission Parameters:

Post-Emission State:

Trace:

[SC-5 check] capacity_remaining = 0 → capture of E_4 blocked
[decision] f_Emit to expand capacity_MAX
[EC-1 check] ρ(Φ) = 0.45 < 1.0 → headroom = 0.55 ✅
[EC-2 check] r_emit = 6.0 ≤ r_capture = 9.2 ✅
[compute_emit_cost] E_emit = 8.00 × 0.05 × 36 = 14.40
[emit_field] ρ(Φ): 0.45 → 0.50
[capacity_MAX] 2 → 3 (SC-5 now satisfied for E_4)
[f_Capture] E_4 captured — SC-1 through SC-5 all satisfied

Outcome: Frame capacity expanded from 2 to 3 via a minimal, cost-efficient f_Emit call (E_emit = 14.40). E_4 successfully captured without requiring any collapse of existing relationships.

§8.3 — Example 3: Cold-Start Bootstrap#

Scenario: A newly initialized attractor A has ρ(Φ) = 0.0 (field not yet established). FM-002 (Zero Field) is active. No captures are possible until ρ(Φ) > 0. A bootstrap emission sequence is required to bring the field to a viable operating density.

Initial Parameters:

Bootstrap Sequence (3 pulses, conservative approach):

Post-Bootstrap State:

Trace:

[FM-002 active] ρ(Φ) = 0.0 → no captures possible
[Pulse 1] EC-1: 0.0 < 1.0 ✅ | EC-2: 4.0 ≤ 7.0 ✅
          emit_field → ρ(Φ): 0.00 → 0.20 | FIELD_COLLAPSED cleared ✅
[Pulse 2] EC-1: 0.2 < 1.0 ✅ | EC-2: 5.0 ≤ 7.0 ✅
          emit_field → ρ(Φ): 0.20 → 0.40
[Pulse 3] EC-1: 0.4 < 1.0 ✅ | EC-2: 6.0 ≤ 7.0 ✅
          emit_field → ρ(Φ): 0.40 → 0.55
[SC-2] ρ(Φ) = 0.55 > 0 ✅ | field uniform within r_emit = 6.0 ✅
[operational] A ready for capture attempts — FM-002 resolved

Outcome: A cold attractor bootstrapped to ρ(Φ) = 0.55 via 3 progressive pulses. Total cost: 47.60 energy units. FM-002 cleared after Pulse 1. The progressive pulse pattern (expanding r_emit each pulse) ensures spatial coherence builds from the center outward, avoiding discontinuities in the field state.

§8.4 — Example 4: FM-010 Trigger and Prevention#

Scenario: An automated emission loop is running to sustain ρ(Φ) during high-activity capture operations. The loop fails to check EMIT_CEILING_APPROACHED and drives ρ(Φ) to 1.0, triggering FM-010.

Part A — FM-010 Trigger:

[Loop iter 4] EC-1: ρ(Φ) = 1.0 ≥ 1.0 → VIOLATION
              FM-010 raised: FM010Error("Amplify Runaway")
              EMIT_SATURATED flag set
              Loop terminates (
Resuming exactly where the file was cut. Paste this block immediately after the truncation point (starting at the `Loop terminates (unhandled exception if not caught))

Part A Interpretation: The loop correctly ran for iterations 1–3, with iter 3 delivering a clipped increment (requested 0.10, headroom = 0.10, so ρ(Φ)_delta = 0.10 — exactly at ceiling). Iter 4 finds ρ(Φ) = 1.0, EC-1 fails, and FM-010 fires. The error is recoverable but interrupts the loop.

Part B — Prevention (Corrected Pattern):

The correct automated emission loop checks EMIT_CEILING_APPROACHED and pauses before FM-010 can fire:

def sustained_emission_loop(
    attractor: Attractor,
    phi: FieldState,
    target_rho: float,
    delta_rho_per_pulse: float,
    r_emit: float,
    max_pulses: int = 100,
    headroom_reserve: float = 0.05
) -> tuple[FieldState, int]:
    """
    Safe sustained emission loop with FM-010 prevention.
 
    Emits in repeated pulses toward target_rho, stopping automatically
    when ρ(Φ) approaches the ceiling or the target is reached.
 
    Args:
        attractor:          Attractor whose field is being deepened.
        phi:                Current field state.
        target_rho:         Desired final ρ(Φ) (must be < 1.0).
        delta_rho_per_pulse: Density increment per pulse.
        r_emit:             Emission radius (EC-2 constraint applies).
        max_pulses:         Safety cap on loop iterations.
        headroom_reserve:   Minimum headroom to maintain (stop before
                            dropping below this). Default 0.05 = 5%.
 
    Returns:
        Tuple of (updated FieldState, pulses_executed).
 
    Raises:
        ValueError: If target_rho ≥ 1.0 or target_rho ≤ phi.rho.
    """
    if target_rho >= 1.0:
        raise ValueError(f"target_rho must be < 1.0; got {target_rho}")
    if target_rho <= phi.rho:
        return phi, 0  # already at or above target
 
    pulses = 0
    while pulses < max_pulses:
        # FM-010 prevention: check headroom before each pulse
        ceiling_ok, headroom = check_emit_ceiling(phi)  # PRIM:017
 
        if not ceiling_ok:
            # Should never reach here in a safe loop, but defensive guard
            break
 
        # Stop if we've hit the headroom reserve floor
        if headroom < headroom_reserve:
            # EMIT_CEILING_APPROACHED is set — pause and let natural decay
            # restore some headroom before resuming, or call f_Dampen
            break
 
        # Stop if target is reached
        if phi.rho >= target_rho:
            break
 
        # Clip pulse to minimum of: requested delta, available headroom,
        # and remaining distance to target
        delta_this_pulse = min(
            delta_rho_per_pulse,
            headroom - headroom_reserve,        # keep reserve
            target_rho - phi.rho                # don't overshoot target
        )
 
        if delta_this_pulse <= 0:
            break
 
        phi = emit_field(attractor, phi, delta_this_pulse, r_emit)  # PRIM:015
        pulses += 1
 
    return phi, pulses

Corrected loop trace for Example 4:

Outcome: FM-010 prevented by headroom_reserve guard. Loop exits cleanly at ρ(Φ) = 0.95 with 5% headroom intact. If more emission is needed, the caller must either accept the current level, wait for natural decay to free headroom, or call f_Dampen to intentionally lower ρ(Φ) before resuming.

Key lesson: FM-010 is always an engineering error, never an unavoidable condition. Any emission loop that lacks a check_emit_ceiling call and a headroom reserve will eventually trigger it. PRIM:017 exists precisely to prevent this.

§9 — Cross-Module References#

§9.1 — Files That Call f_Emit#

§9.2 — Files That f_Emit Depends On#

§9.3 — Files That Interact Inversely#

§9.4 — GravityGraph Events Emitted#

When emit_field executes and a GravityGraph observer is registered, the following events are dispatched:

§9.5 — OPERATORS.md Updates Required#

The following entries must be updated in OPERATORS.md after this file is committed:

§10 — Document Metadata#

§10.1 — INV Compliance Table#

§10.2 — Primitive Registry (f_Emit.md Additions)#

§10.3 — Operator Registry (f_Emit.md Additions)#

§10.4 — Failure Mode Registry (f_Emit.md)#

§10.5 — Wave 3 Status#

§10.6 — Changelog Entry#

## [1.0.0] — 2026-08-13 — SES-20260813-EMIT-001

### Added
- f_Emit.md — canonical Wave 3 file 5 of 8
- Operators frozen: F_emit, ρ(Φ)_delta, r_emit, E_emit
- Primitives frozen: PRIM:015 emit_field, PRIM:016 compute_emit_cost,
  PRIM:017 check_emit_ceiling
- FM-010 (Amplify Runaway) fully specified and frozen
- State flags frozen: EMIT_ACTIVE, EMIT_SATURATED, EMIT_CEILING_APPROACHED
- Emit Conditions EC-1 (Headroom Bound) and EC-2 (Radius Bound) defined
- 4 canonical examples: FM-004 recovery, frame capacity expansion,
  cold-start bootstrap, FM-010 trigger and prevention
- sustained_emission_loop safe pattern with headroom_reserve guard
- GravityGraph event interface specified (4 event types)

### Operator Status Updates Required in OPERATORS.md
- F_emit:           🔵 → 🟢 frozen (f_Emit.md §4.1)
- ρ(Φ)_delta:       🔵 → 🟢 frozen (f_Emit.md §4.1)
- r_emit:           🔵 → 🟢 frozen (f_Emit.md §4.1)
- E_emit:           🔵 → 🟢 frozen (f_Emit.md §4.1)
- PRIM:015-017:     pending → frozen (f_Emit.md §7)
- FM-010:           pending → frozen (f_Emit.md §6.1)

End of f_Emit.md — canonical v1.0.0 — [FFF:GRAVITY:EMIT] — SES-20260813-EMIT-001