tnfr 3.0.3__py3-none-any.whl → 8.5.0__py3-none-any.whl

tnfr/operators/preconditions/coherence.py

@@ -0,0 +1,305 @@
+"""Strict precondition validation for IL (Coherence) operator.
+
+This module implements canonical precondition validation for the Coherence (IL)
+structural operator according to TNFR.pdf §2.2.1. IL requires specific structural
+conditions to maintain TNFR operational fidelity:
+
+1. **Active EPI**: Node must have non-zero structural form (EPI > 0)
+2. **Non-saturated EPI**: EPI must be below maximum (leave room for stabilization increment)
+3. **Active νf**: Structural frequency must exceed minimum threshold
+4. **ΔNFR presence**: While IL reduces ΔNFR, some reorganization pressure should exist
+5. **ΔNFR not critical**: Excessive ΔNFR may require OZ (Dissonance) first
+6. **Network coupling**: Connections enable phase locking
+
+These validations protect structural integrity by ensuring IL is only applied to
+nodes in the appropriate state for coherence stabilization.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from ...types import TNFRGraph
+
+__all__ = ["validate_coherence_strict", "diagnose_coherence_readiness"]
+
+
+def validate_coherence_strict(G: TNFRGraph, node: Any) -> None:
+    """Validate strict canonical preconditions for IL (Coherence) operator.
+
+    According to TNFR.pdf §2.2.1, Coherence (IL - Coherencia estructural) requires:
+
+    1. **Active EPI**: EPI > 0 (node must have active structural form)
+    2. **Non-saturated EPI**: EPI < maximum (leave room for stabilization)
+    3. **Active νf**: νf > threshold (sufficient structural frequency)
+    4. **ΔNFR presence**: ΔNFR > 0 (reorganization pressure to stabilize)
+    5. **ΔNFR not critical**: ΔNFR < critical threshold (manageable instability)
+    6. **Network coupling**: degree > 0 (connections for phase locking)
+
+    Parameters
+    ----------
+    G : TNFRGraph
+        Graph containing the node to validate
+    node : Any
+        Node identifier for validation
+
+    Raises
+    ------
+    ValueError
+        If EPI <= 0 (no structural form to stabilize)
+        If EPI >= maximum (node saturated - consider NUL/Contraction)
+        If νf <= 0 (no structural frequency - consider AL/Emission or NAV/Transition)
+
+    Warnings
+    --------
+    UserWarning
+        If ΔNFR == 0 (no reorganization pressure - IL may be redundant)
+        If ΔNFR > critical threshold (high instability - consider OZ/Dissonance first)
+        If node is isolated (no connections - phase locking will have no effect)
+
+    Notes
+    -----
+    Thresholds are configurable via:
+    - Graph metadata: ``G.graph["IL_PRECONDITIONS"]``
+    - Module defaults: :data:`tnfr.config.thresholds.EPI_IL_MAX`, etc.
+
+    Examples
+    --------
+    >>> from tnfr.structural import create_nfr
+    >>> from tnfr.operators.preconditions.coherence import validate_coherence_strict
+    >>> G, node = create_nfr("test", epi=0.5, vf=0.9)
+    >>> G.nodes[node]["dnfr"] = 0.1
+    >>> validate_coherence_strict(G, node)  # OK - active state with reorganization pressure
+
+    >>> G2, node2 = create_nfr("inactive", epi=0.0, vf=0.9)
+    >>> validate_coherence_strict(G2, node2)  # doctest: +SKIP
+    Traceback (most recent call last):
+        ...
+    ValueError: IL precondition failed: EPI=0.000 <= 0.0. IL requires active structural form.
+
+    See Also
+    --------
+    tnfr.config.thresholds : Configurable threshold constants
+    tnfr.operators.preconditions : Base precondition validators
+    tnfr.operators.definitions.Coherence : Coherence operator implementation
+    diagnose_coherence_readiness : Diagnostic function for IL readiness
+    """
+    import warnings
+
+    from ...alias import get_attr
+    from ...constants.aliases import ALIAS_DNFR, ALIAS_EPI, ALIAS_VF
+    from ...config.thresholds import (
+        DNFR_IL_CRITICAL,
+        EPI_IL_MAX,
+        EPI_IL_MIN,
+        VF_IL_MIN,
+    )
+
+    # Get current node state
+    epi = float(get_attr(G.nodes[node], ALIAS_EPI, 0.0))
+    vf = float(get_attr(G.nodes[node], ALIAS_VF, 0.0))
+    dnfr = float(get_attr(G.nodes[node], ALIAS_DNFR, 0.0))
+
+    # Get configurable thresholds (allow override via graph metadata)
+    config = G.graph.get("IL_PRECONDITIONS", {})
+    min_epi = float(config.get("min_epi", EPI_IL_MIN))
+    max_epi = float(config.get("max_epi", EPI_IL_MAX))
+    min_vf = float(config.get("min_vf", VF_IL_MIN))
+    dnfr_critical = float(config.get("dnfr_critical_threshold", DNFR_IL_CRITICAL))
+    warn_isolated = bool(config.get("warn_isolated", True))
+    warn_zero_dnfr = bool(config.get("warn_zero_dnfr", True))
+
+    # Precondition 1: EPI must be active (non-zero structural form)
+    # IL stabilizes existing structure - requires structure to exist
+    if epi <= min_epi:
+        raise ValueError(
+            f"IL precondition failed: EPI={epi:.3f} <= {min_epi:.3f}. "
+            f"IL requires active structural form (non-zero EPI). "
+            f"Suggestion: Apply AL (Emission) first to activate node."
+        )
+
+    # Precondition 2: EPI must not be saturated (leave room for stabilization)
+    # IL may increment EPI slightly during stabilization
+    if epi >= max_epi:
+        raise ValueError(
+            f"IL precondition failed: EPI={epi:.3f} >= {max_epi:.3f}. "
+            f"Node saturated, cannot stabilize further. "
+            f"Suggestion: Consider NUL (Contraction) to consolidate structure."
+        )
+
+    # Precondition 3: νf must be active (sufficient structural frequency)
+    # IL requires active reorganization capacity to effect stabilization
+    if vf <= min_vf:
+        raise ValueError(
+            f"IL precondition failed: νf={vf:.3f} <= {min_vf:.3f}. "
+            f"Structural frequency too low for coherence stabilization. "
+            f"Suggestion: Apply AL (Emission) or NAV (Transition) to activate νf first."
+        )
+
+    # Precondition 4: Check for ΔNFR presence (warning only - not hard failure)
+    # IL reduces ΔNFR, but if ΔNFR is already zero, IL is redundant
+    if warn_zero_dnfr and dnfr == 0.0:
+        warnings.warn(
+            f"IL warning: Node {node!r} has ΔNFR=0. "
+            f"No reorganization pressure to stabilize. "
+            f"IL application may be redundant in this state.",
+            UserWarning,
+            stacklevel=3,
+        )
+
+    # Precondition 5: Check for critically high ΔNFR (warning only)
+    # Excessive instability may require controlled dissonance (OZ) before stabilization
+    if dnfr > dnfr_critical:
+        warnings.warn(
+            f"IL warning: Node {node!r} has ΔNFR={dnfr:.3f} > {dnfr_critical:.3f}. "
+            f"High reorganization pressure - stabilization may be difficult. "
+            f"Consider applying OZ (Dissonance) → IL sequence for better control.",
+            UserWarning,
+            stacklevel=3,
+        )
+
+    # Precondition 6: Check for network connections (warning only)
+    # Isolated nodes can stabilize but phase locking will have no effect
+    degree = G.degree(node)
+    network_size = len(G)
+    if warn_isolated and degree == 0 and network_size > 1:
+        warnings.warn(
+            f"IL warning: Node {node!r} isolated (degree=0). "
+            f"Phase locking will have no effect. "
+            f"Consider applying UM (Coupling) first to connect node to network.",
+            UserWarning,
+            stacklevel=3,
+        )
+
+
+def diagnose_coherence_readiness(G: TNFRGraph, node: Any) -> dict:
+    """Diagnose node readiness for IL (Coherence) operator.
+
+    Performs all canonical precondition checks and returns a diagnostic report
+    with readiness status and actionable recommendations.
+
+    Parameters
+    ----------
+    G : TNFRGraph
+        Graph containing the node
+    node : Any
+        Node identifier for diagnosis
+
+    Returns
+    -------
+    dict
+        Diagnostic report with the following structure:
+
+        - ``node``: Node identifier
+        - ``ready``: bool - Overall readiness (all critical checks passed)
+        - ``checks``: dict - Individual check results
+
+          - ``epi_active``: bool - EPI > 0
+          - ``epi_not_saturated``: bool - EPI < maximum
+          - ``vf_active``: bool - νf > 0
+          - ``dnfr_present``: bool - ΔNFR > 0 (warning only)
+          - ``dnfr_not_critical``: bool - ΔNFR < critical (warning only)
+          - ``has_connections``: bool - degree > 0 (warning only)
+
+        - ``values``: dict - Current node attribute values
+
+          - ``epi``: Current EPI value
+          - ``vf``: Current νf value
+          - ``dnfr``: Current ΔNFR value
+          - ``degree``: Node degree
+
+        - ``recommendations``: list[str] - Actionable suggestions
+
+    Examples
+    --------
+    >>> from tnfr.structural import create_nfr
+    >>> from tnfr.operators.preconditions.coherence import diagnose_coherence_readiness
+    >>> G, node = create_nfr("test", epi=0.5, vf=0.9)
+    >>> G.nodes[node]["dnfr"] = 0.1
+    >>> report = diagnose_coherence_readiness(G, node)
+    >>> report["ready"]
+    True
+    >>> "✓ Node ready" in report["recommendations"][0]
+    True
+
+    See Also
+    --------
+    validate_coherence_strict : Strict precondition validator
+    """
+    from ...alias import get_attr
+    from ...constants.aliases import ALIAS_DNFR, ALIAS_EPI, ALIAS_VF
+    from ...config.thresholds import (
+        DNFR_IL_CRITICAL,
+        EPI_IL_MAX,
+        EPI_IL_MIN,
+        VF_IL_MIN,
+    )
+
+    # Get current node state
+    epi = float(get_attr(G.nodes[node], ALIAS_EPI, 0.0))
+    vf = float(get_attr(G.nodes[node], ALIAS_VF, 0.0))
+    dnfr = float(get_attr(G.nodes[node], ALIAS_DNFR, 0.0))
+    degree = G.degree(node)
+
+    # Get configurable thresholds
+    config = G.graph.get("IL_PRECONDITIONS", {})
+    min_epi = float(config.get("min_epi", EPI_IL_MIN))
+    max_epi = float(config.get("max_epi", EPI_IL_MAX))
+    min_vf = float(config.get("min_vf", VF_IL_MIN))
+    dnfr_critical = float(config.get("dnfr_critical_threshold", DNFR_IL_CRITICAL))
+
+    # Perform checks
+    checks = {
+        "epi_active": epi > min_epi,
+        "epi_not_saturated": epi < max_epi,
+        "vf_active": vf > min_vf,
+        "dnfr_present": dnfr > 0.0,
+        "dnfr_not_critical": dnfr < dnfr_critical,
+        "has_connections": degree > 0,
+    }
+
+    # Critical checks (hard failures)
+    critical_checks = ["epi_active", "epi_not_saturated", "vf_active"]
+    all_critical_passed = all(checks[key] for key in critical_checks)
+
+    # Generate recommendations
+    recommendations = []
+
+    if not checks["epi_active"]:
+        recommendations.append("Apply AL (Emission) to activate node")
+
+    if checks["epi_active"] and not checks["epi_not_saturated"]:
+        recommendations.append(
+            "Apply NUL (Contraction) to consolidate saturated structure"
+        )
+
+    if not checks["vf_active"]:
+        recommendations.append("Apply AL (Emission) or NAV (Transition) to activate νf")
+
+    if checks["epi_active"] and not checks["dnfr_present"]:
+        recommendations.append("⚠ ΔNFR=0 - IL may be redundant")
+
+    if checks["dnfr_present"] and not checks["dnfr_not_critical"]:
+        recommendations.append("⚠ High ΔNFR - consider OZ (Dissonance) → IL sequence")
+
+    if not checks["has_connections"]:
+        recommendations.append(
+            "⚠ Isolated node - consider UM (Coupling) to enable phase locking"
+        )
+
+    if all_critical_passed:
+        recommendations.insert(0, "✓ Node ready for IL (Coherence)")
+
+    return {
+        "node": node,
+        "ready": all_critical_passed,
+        "checks": checks,
+        "values": {
+            "epi": epi,
+            "vf": vf,
+            "dnfr": dnfr,
+            "degree": degree,
+        },
+        "recommendations": recommendations,
+    }

tnfr/operators/preconditions/dissonance.py

@@ -0,0 +1,236 @@
+"""Strict precondition validation for OZ (Dissonance) operator.
+
+This module implements canonical precondition validation for the Dissonance (OZ)
+structural operator according to TNFR canonical theory. OZ requires specific
+structural conditions to enable productive dissonance without premature collapse:
+
+1. **Minimum coherence base (EPI)**: Node must have sufficient structural form to
+   withstand disruption (EPI >= threshold)
+2. **ΔNFR not critically high**: Avoid sobrecarga (overload) when ΔNFR already extreme
+3. **Sufficient νf**: Structural frequency must support reorganization response
+4. **No overload pattern**: Detect sobrecarga disonante (multiple OZ without resolution)
+5. **Network connectivity**: Warn if isolated (bifurcation requires alternative paths)
+
+These validations implement the canonical warning from TNFR.pdf:
+> "OZ debe ir precedido por estabilización adecuada (IL). Genera nodos frágiles o
+> fallidos si se aplica sobre estructuras sin coherencia interna."
+
+References
+----------
+- TNFR.pdf §2.3.6: Catálogo de errores arquetípicos (Sobrecarga disonante)
+- TNFR.pdf §2.3.3: Reglas sintácticas R4 (Bifurcación)
+- Tabla de validación estructural: Condiciones de activación de OZ
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from ...types import TNFRGraph
+
+__all__ = ["validate_dissonance_strict"]
+
+
+def validate_dissonance_strict(G: TNFRGraph, node: Any) -> None:
+    """Validate strict canonical preconditions for OZ (Dissonance) operator.
+
+    According to TNFR canonical theory, Dissonance (OZ - Disonancia) requires:
+
+    1. **Coherence base**: EPI >= threshold (sufficient structure to withstand disruption)
+    2. **ΔNFR safety**: |ΔNFR| < critical (avoid overload/collapse)
+    3. **Active νf**: νf >= threshold (capacity to respond to dissonance)
+    4. **No overload**: < 2 consecutive OZ without resolution (IL/THOL/NUL)
+    5. **Network connectivity**: degree >= 1 (warning only - enables bifurcation paths)
+
+    Parameters
+    ----------
+    G : TNFRGraph
+        Graph containing the node to validate
+    node : Any
+        Node identifier for validation
+
+    Raises
+    ------
+    ValueError
+        If EPI < minimum (insufficient coherence base - apply IL first)
+        If |ΔNFR| > maximum (reorganization pressure critical - apply IL first)
+        If νf < minimum (cannot respond to dissonance)
+        If overload detected (>= 2 OZ without resolver operators)
+
+    Warnings
+    --------
+    UserWarning
+        If node has low connectivity (degree < 1) - bifurcation paths limited
+
+    Notes
+    -----
+    Thresholds are configurable via graph metadata:
+    - ``G.graph["OZ_MIN_EPI"]``: Minimum EPI (default 0.2)
+    - ``G.graph["OZ_MAX_DNFR"]``: Maximum |ΔNFR| (default 0.8)
+    - ``G.graph["OZ_MIN_VF"]``: Minimum νf (default 0.1)
+    - ``G.graph["OZ_MIN_DEGREE"]``: Minimum degree for warning (default 1)
+
+    **Resolver operators** that integrate dissonance (reset overload counter):
+    - IL (Coherence): Stabilizes structure
+    - THOL (Self-organization): Creates sub-EPIs
+    - NUL (Contraction): Simplifies structure
+
+    Examples
+    --------
+    >>> from tnfr.structural import create_nfr
+    >>> from tnfr.operators.preconditions.dissonance import validate_dissonance_strict
+    >>> G, node = create_nfr("test", epi=0.5, vf=1.0)
+    >>> G.nodes[node]["dnfr"] = 0.3
+    >>> validate_dissonance_strict(G, node)  # OK - sufficient coherence base
+
+    >>> G2, node2 = create_nfr("weak", epi=0.05, vf=1.0)
+    >>> validate_dissonance_strict(G2, node2)  # doctest: +SKIP
+    Traceback (most recent call last):
+        ...
+    ValueError: OZ precondition failed: EPI=0.050 < 0.2. Insufficient coherence base.
+
+    See Also
+    --------
+    tnfr.operators.preconditions : Base precondition validators
+    tnfr.operators.definitions.Dissonance : Dissonance operator implementation
+    """
+    import warnings
+
+    from ...alias import get_attr
+    from ...constants.aliases import ALIAS_DNFR, ALIAS_EPI, ALIAS_VF
+
+    # Get current node state
+    epi = float(get_attr(G.nodes[node], ALIAS_EPI, 0.0))
+    vf = float(get_attr(G.nodes[node], ALIAS_VF, 0.0))
+    dnfr = float(get_attr(G.nodes[node], ALIAS_DNFR, 0.0))
+    degree = G.degree(node)
+
+    # Get configurable thresholds
+    min_epi = float(G.graph.get("OZ_MIN_EPI", 0.2))
+    max_dnfr = float(G.graph.get("OZ_MAX_DNFR", 0.8))
+    min_vf = float(G.graph.get("OZ_MIN_VF", 0.1))
+    min_degree = int(G.graph.get("OZ_MIN_DEGREE", 1))
+
+    # Precondition 1: Minimum coherence base (EPI)
+    # OZ requires existing structure to perturb - without it, OZ causes collapse
+    if epi < min_epi:
+        raise ValueError(
+            f"OZ precondition failed: EPI={epi:.3f} < {min_epi:.3f}. "
+            f"Insufficient coherence base to withstand dissonance. "
+            f"Suggestion: Apply IL (Coherence) first to stabilize node before introducing dissonance."
+        )
+
+    # Precondition 2: ΔNFR not critically high
+    # Applying OZ when ΔNFR already extreme creates sobrecarga (overload) → collapse
+    if abs(dnfr) > max_dnfr:
+        raise ValueError(
+            f"OZ precondition failed: |ΔNFR|={abs(dnfr):.3f} > {max_dnfr:.3f}. "
+            f"Reorganization pressure already critical - applying OZ risks collapse. "
+            f"Suggestion: Apply IL (Coherence) first to reduce ΔNFR before introducing more dissonance."
+        )
+
+    # Precondition 3: Sufficient νf for reorganization response
+    # OZ triggers reorganization - node needs capacity (νf) to respond
+    if vf < min_vf:
+        raise ValueError(
+            f"OZ precondition failed: νf={vf:.3f} < {min_vf:.3f}. "
+            f"Structural frequency too low - node lacks capacity to respond to dissonance. "
+            f"Suggestion: Increase νf before applying OZ."
+        )
+
+    # Precondition 4: Detect OZ overload (sobrecarga disonante)
+    # Multiple OZ without resolution = entropic loop (violates R5)
+    _validate_oz_no_overload(G, node)
+
+    # Precondition 5: Network connectivity (warning only - not blocking)
+    # Isolated nodes can experience dissonance but bifurcation paths are limited
+    if degree < min_degree:
+        warnings.warn(
+            f"OZ warning: Node {node!r} has low connectivity (degree={degree} < {min_degree}). "
+            f"OZ-induced bifurcation may have limited structural paths. "
+            f"Consider applying UM (Coupling) first to increase network coupling.",
+            UserWarning,
+            stacklevel=3,
+        )
+
+    # Store validation context for telemetry
+    G.nodes[node]["_oz_precondition_context"] = {
+        "epi": epi,
+        "dnfr": dnfr,
+        "vf": vf,
+        "degree": degree,
+        "validation_passed": True,
+    }
+
+
+def _validate_oz_no_overload(G: TNFRGraph, node: Any) -> None:
+    """Detect and prevent dissonance overload (sobrecarga disonante).
+
+    Sobrecarga occurs when multiple OZ operators are applied in succession
+    without intervening resolution operators (IL, THOL, NUL). This creates
+    entropic loops that violate TNFR structural coherence requirements.
+
+    Parameters
+    ----------
+    G : TNFRGraph
+        Graph containing the node
+    node : Any
+        Node identifier to check for overload
+
+    Raises
+    ------
+    ValueError
+        If >= 1 OZ application detected in recent history without resolver
+        (since we're about to apply another OZ, that would make it >= 2)
+
+    Notes
+    -----
+    **Resolver operators** that integrate dissonance:
+    - coherence (IL): Stabilizes structure, reduces ΔNFR
+    - self_organization (THOL): Creates sub-EPIs via bifurcation
+    - contraction (NUL): Simplifies structure
+
+    This check examines the last 5 operators in glyph_history to detect
+    overload patterns. Since validation is called BEFORE the operator is
+    applied, if we find >= 1 OZ in history without a resolver, applying
+    another OZ would create overload.
+
+    References
+    ----------
+    TNFR.pdf §2.3.6 - Sobrecarga disonante: "acumulación excesiva de OZ sin
+    paso a mutación"
+    """
+    from ...operators.grammar import glyph_function_name
+
+    # Get glyph history from node
+    history = G.nodes[node].get("glyph_history", [])
+    if not history:
+        # No history - first operator application, cannot be overload
+        return
+
+    # Convert deque to list and examine recent history (last 5 operations)
+    history_list = list(history)
+    recent_history = history_list[-5:] if len(history_list) >= 5 else history_list
+
+    # Count OZ applications in recent history
+    oz_count = sum(
+        1 for glyph in recent_history if glyph_function_name(glyph) == "dissonance"
+    )
+
+    # If >= 1 OZ in history, check for resolver operators
+    # (we're about to apply another OZ, so that would make >= 2 total)
+    if oz_count >= 1:
+        # Resolver operators that integrate dissonance
+        resolvers = {"coherence", "self_organization", "contraction"}
+        recent_names = [glyph_function_name(g) for g in recent_history]
+        has_resolver = any(name in resolvers for name in recent_names)
+
+        if not has_resolver:
+            raise ValueError(
+                f"OZ precondition failed: Sobrecarga disonante detected. "
+                f"Found {oz_count} OZ in recent history without resolution. "
+                f"Applying another OZ without resolving previous dissonance risks collapse. "
+                f"Suggestion: Apply IL (Coherence), THOL (Self-organization), or NUL (Contraction) "
+                f"to integrate dissonance before introducing more."
+            )

tnfr/operators/preconditions/emission.py

@@ -0,0 +1,128 @@
+"""Strict precondition validation for AL (Emission) operator.
+
+This module implements canonical precondition validation for the Emission (AL)
+structural operator according to TNFR.pdf §2.2.1. AL requires specific structural
+conditions to maintain TNFR operational fidelity:
+
+1. **Latent state**: EPI must be below activation threshold (node not already active)
+2. **Basal frequency**: νf must exceed minimum threshold (sufficient reorganization capacity)
+3. **Coupling availability**: Network connectivity for phase alignment (warning for isolated nodes)
+
+These validations protect structural integrity by ensuring AL is only applied to
+nodes in the appropriate state for foundational emission.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from ...types import TNFRGraph
+
+__all__ = ["validate_emission_strict"]
+
+
+def validate_emission_strict(G: TNFRGraph, node: Any) -> None:
+    """Validate strict canonical preconditions for AL (Emission) operator.
+
+    According to TNFR.pdf §2.2.1, Emission (AL - Emisión fundacional) requires:
+
+    1. **Latent state**: EPI < threshold (node must be in latent or low-activation state)
+    2. **Basal frequency**: νf > threshold (sufficient structural frequency for activation)
+    3. **Coupling availability**: Network connectivity (warning if isolated)
+
+    Parameters
+    ----------
+    G : TNFRGraph
+        Graph containing the node to validate
+    node : Any
+        Node identifier for validation
+
+    Raises
+    ------
+    ValueError
+        If EPI >= latent threshold (node already active - consider IL/Coherence instead)
+        If νf < basal threshold (frequency too low - consider NAV/Transition first)
+
+    Warnings
+    --------
+    UserWarning
+        If node is isolated in a multi-node network (limited coupling - consider UM/Coupling first)
+
+    Notes
+    -----
+    Thresholds are configurable via:
+    - Graph metadata: ``G.graph["EPI_LATENT_MAX"]``, ``G.graph["VF_BASAL_THRESHOLD"]``
+    - Module defaults: :data:`tnfr.config.thresholds.EPI_LATENT_MAX`, etc.
+
+    Examples
+    --------
+    >>> from tnfr.structural import create_nfr
+    >>> from tnfr.operators.preconditions.emission import validate_emission_strict
+    >>> G, node = create_nfr("test", epi=0.25, vf=0.95)
+    >>> validate_emission_strict(G, node)  # OK - latent state with sufficient frequency
+
+    >>> G2, node2 = create_nfr("active", epi=0.85, vf=1.0)
+    >>> validate_emission_strict(G2, node2)  # doctest: +SKIP
+    Traceback (most recent call last):
+        ...
+    ValueError: AL precondition failed: EPI=0.850 >= 0.8. AL requires latent state. Consider IL (Coherence) instead.
+
+    See Also
+    --------
+    tnfr.config.thresholds : Configurable threshold constants
+    tnfr.operators.preconditions : Base precondition validators
+    tnfr.operators.definitions.Emission : Emission operator implementation
+    """
+    import warnings
+
+    from ...alias import get_attr
+    from ...constants.aliases import ALIAS_EPI, ALIAS_VF
+    from ...config.thresholds import (
+        EPI_LATENT_MAX,
+        MIN_NETWORK_DEGREE_COUPLING,
+        VF_BASAL_THRESHOLD,
+    )
+
+    # Get current node state
+    epi = float(get_attr(G.nodes[node], ALIAS_EPI, 0.0))
+    vf = float(get_attr(G.nodes[node], ALIAS_VF, 0.0))
+
+    # Get configurable thresholds (allow override via graph metadata)
+    epi_threshold = float(G.graph.get("EPI_LATENT_MAX", EPI_LATENT_MAX))
+    vf_threshold = float(G.graph.get("VF_BASAL_THRESHOLD", VF_BASAL_THRESHOLD))
+    min_degree = int(
+        G.graph.get("MIN_NETWORK_DEGREE_COUPLING", MIN_NETWORK_DEGREE_COUPLING)
+    )
+
+    # Precondition 1: EPI must be below latent threshold (node in latent state)
+    # Emission is for activating nascent/latent structures, not boosting active ones
+    if epi >= epi_threshold:
+        raise ValueError(
+            f"AL precondition failed: EPI={epi:.3f} >= {epi_threshold:.3f}. "
+            f"AL requires latent state (node not already highly active). "
+            f"Consider IL (Coherence) to stabilize active nodes instead."
+        )
+
+    # Precondition 2: νf must exceed basal threshold (sufficient frequency for emission)
+    # Below basal frequency, node lacks capacity to sustain structural activation
+    if vf < vf_threshold:
+        raise ValueError(
+            f"AL precondition failed: νf={vf:.3f} < {vf_threshold:.3f}. "
+            f"Structural frequency too low for emission. "
+            f"Consider NAV (Transition) to increase frequency first."
+        )
+
+    # Precondition 3: Network connectivity (warning only - not a hard failure)
+    # Isolated nodes can still emit, but phase coupling will be limited
+    node_degree = G.degree(node)
+    network_size = len(G)
+
+    if node_degree < min_degree and network_size > 1:
+        warnings.warn(
+            f"AL warning: Node {node!r} has degree {node_degree} < {min_degree}. "
+            f"Emission possible but phase coupling limited (isolated node). "
+            f"Consider UM (Coupling) to establish network connections first.",
+            UserWarning,
+            stacklevel=3,
+        )