Implement U5: Multi-Scale Coherence grammar rule

Intent: Add U5 canonical grammar constraint for multi-scale coherence preservation
Operators involved: REMESH (Recursivity), IL (Coherence), THOL (Self-organization)
Affected invariants: #7 (Operational Fractality), #2 (Structural Units)

Key changes:
- Added RECURSIVE_GENERATORS and SCALE_STABILIZERS operator sets
- Implemented validate_multiscale_coherence() in GrammarValidator
- Added depth parameter to Recursivity operator (default=1)
- Updated unified_grammar.py facade to export U5 sets
- Integrated U5 validation into grammar pipeline

Physical basis:
- Conservation of coherence: C_parent ≥ α·ΣC_child_i
- Factor α = (1/√N)·η_phase(N)·η_coupling(N) ∈ [0.1, 0.4]
- Operates in SPATIAL dimension (hierarchy) vs U1-U4 (TEMPORAL)
- Independent of U2+U4b per decision test case

Metrics: U5 ensures bounded multi-scale evolution when depth>1

Co-authored-by: fermga <203334638+fermga@users.noreply.github.com>

Author: Copilot

src/tnfr/operators/definitions.py

@@ -4064,6 +4064,21 @@ class Recursivity(Operator):
 
     Critical: REMESH preserves identity across scales - fundamental to TNFR fractality.
 
+    Parameters
+    ----------
+    depth : int, optional
+        Hierarchical nesting depth for multi-scale recursion (default: 1).
+        - depth=1: Shallow recursion (single level, no multi-scale constraint)
+        - depth>1: Deep recursion (multi-level hierarchy, requires U5 stabilizers)
+        
+    Notes
+    -----
+    **U5: Multi-Scale Coherence**: When depth>1, U5 grammar rule applies requiring
+    scale stabilizers (IL or THOL) within ±3 operators to preserve coherence across
+    hierarchical levels. This ensures C_parent ≥ α·ΣC_child per conservation principle.
+    
+    See UNIFIED_GRAMMAR_RULES.md § U5 for complete physical derivation.
+
     Examples
     --------
     >>> from tnfr.constants import EPI_PRIMARY, VF_PRIMARY
@@ -4083,16 +4098,33 @@ class Recursivity(Operator):
     >>> run_sequence(G, node, [Recursivity()])
     >>> G.graph["echo_trace"]
     [(0.54, 0.95)]
+    
+    Deep recursion example requiring U5 stabilizers:
+    >>> from tnfr.operators.definitions import Recursivity, Coherence, Silence
+    >>> # depth=3 creates multi-level hierarchy - requires IL for U5
+    >>> ops = [Recursivity(depth=3), Coherence(), Silence()]
 
     **Biomedical**: Fractal physiology (HRV, EEG), developmental recapitulation
     **Cognitive**: Recursive thinking, meta-cognition, self-referential processes
     **Social**: Cultural fractals, organizational self-similarity, meme propagation
     """
 
-    __slots__ = ()
+    __slots__ = ("depth",)
     name: ClassVar[str] = RECURSIVITY
     glyph: ClassVar[Glyph] = Glyph.REMESH
 
+    def __init__(self, depth: int = 1):
+        """Initialize Recursivity operator with hierarchical depth.
+        
+        Parameters
+        ----------
+        depth : int, optional
+            Nesting depth for multi-scale recursion (default: 1)
+        """
+        if depth < 1:
+            raise ValueError(f"depth must be >= 1, got {depth}")
+        self.depth = depth
+
     def _validate_preconditions(self, G: TNFRGraph, node: Any) -> None:
         """Validate REMESH-specific preconditions."""
         from .preconditions import validate_recursivity

src/tnfr/operators/grammar.py

@@ -199,6 +199,8 @@ def function_name_to_glyph(
     "BIFURCATION_TRIGGERS",
     "BIFURCATION_HANDLERS",
     "TRANSFORMERS",
+    "RECURSIVE_GENERATORS",
+    "SCALE_STABILIZERS",
 ]
 
 
@@ -230,6 +232,10 @@ def function_name_to_glyph(
 # U4b: Transformers - Execute structural bifurcations
 TRANSFORMERS = frozenset({"mutation", "self_organization"})
 
+# U5: Multi-Scale Coherence - Recursive generators and scale stabilizers
+RECURSIVE_GENERATORS = frozenset({"recursivity"})
+SCALE_STABILIZERS = frozenset({"coherence", "self_organization"})
+
 
 # ============================================================================
 # Grammar Errors
@@ -894,6 +900,120 @@ def validate_remesh_amplification(sequence: List[Operator]) -> tuple[bool, str]:
             f"bound recursive amplification of {destabilizers_present}",
         )
 
+    @staticmethod
+    def validate_multiscale_coherence(sequence: List[Operator]) -> tuple[bool, str]:
+        """Validate U5: Multi-scale coherence preservation.
+
+        Physical basis: Multi-scale hierarchical structures created by REMESH
+        with depth>1 require coherence conservation across scales. This operates
+        in the SPATIAL dimension (hierarchy) versus U1-U4 (TEMPORAL sequences).
+
+        From coherence conservation principle:
+            C_total = C_parent + Σ C_child_i = constant
+
+        For bounded evolution:
+            C_parent ≥ α · Σ C_child_i
+
+        Where α = (1/√N) · η_phase(N) · η_coupling(N)
+        - 1/√N: Scale factor (sublinear growth)
+        - η_phase: Phase synchronization efficiency (decreases with N)
+        - η_coupling: Coupling efficiency (decreases with N)
+        - Typical range: α ∈ [0.1, 0.4]
+
+        Without stabilizers:
+            Deep REMESH (depth>1) creates nested EPIs
+            → Coherence fragments across scales
+            → C_parent < α · Σ C_child (conservation violated)
+            → System fragments
+
+        With stabilizers (IL or THOL):
+            Multi-level coherence stabilization
+            → C_parent ≥ α · Σ C_child (conservation preserved)
+            → Bounded multi-scale evolution
+
+        Parameters
+        ----------
+        sequence : List[Operator]
+            Sequence of operators to validate
+
+        Returns
+        -------
+        tuple[bool, str]
+            (is_valid, message)
+
+        Notes
+        -----
+        U5 is INDEPENDENT of U2+U4b:
+        - U2/U4b: TEMPORAL dimension (operator sequences in time)
+        - U5: SPATIAL dimension (hierarchical nesting in structure)
+
+        Decision test case that passes U2+U4b but fails U5:
+            [AL, REMESH(depth=3), SHA]
+            - U2: ✓ No destabilizers (trivially convergent)
+            - U4b: ✓ REMESH not a transformer (U4b doesn't apply)
+            - U5: ✗ Deep recursivity without stabilization → fragmentation
+
+        Physical derivation: See UNIFIED_GRAMMAR_RULES.md § U5
+        Canonicity: STRONG (derived from conservation of coherence)
+
+        References
+        ----------
+        - Problem statement: "El pulso que nos atraviesa.pdf"
+        - AGENTS.md: Invariant #7 (Operational Fractality)
+        - TNFR.pdf § 2.1: Nodal equation and coherence
+        """
+        # Check for deep REMESH (depth > 1)
+        # Note: Currently Recursivity doesn't expose depth parameter in operator
+        # This is a forward-looking validation for when depth is added
+        deep_remesh_indices = []
+        
+        for i, op in enumerate(sequence):
+            op_name = getattr(op, "canonical_name", op.name.lower())
+            if op_name == "recursivity":
+                # Check if operator has depth attribute
+                depth = getattr(op, "depth", 1)  # Default depth=1 if not present
+                if depth > 1:
+                    deep_remesh_indices.append((i, depth))
+
+        if not deep_remesh_indices:
+            # No deep REMESH present, U5 not applicable
+            return True, "U5: not applicable (no deep recursivity depth>1 present)"
+
+        # For each deep REMESH, check for stabilizers in window
+        violations = []
+        for idx, depth in deep_remesh_indices:
+            # Check window of ±3 operators for scale stabilizers
+            window_start = max(0, idx - 3)
+            window_end = min(len(sequence), idx + 4)
+            
+            has_stabilizer = False
+            stabilizers_in_window = []
+            
+            for j in range(window_start, window_end):
+                op_name = getattr(
+                    sequence[j], "canonical_name", sequence[j].name.lower()
+                )
+                if op_name in SCALE_STABILIZERS:
+                    has_stabilizer = True
+                    stabilizers_in_window.append((j, op_name))
+
+            if not has_stabilizer:
+                violations.append(
+                    f"recursivity at position {idx} (depth={depth}) lacks scale "
+                    f"stabilizer in window [{window_start}:{window_end}]. "
+                    f"Deep hierarchical nesting requires {sorted(SCALE_STABILIZERS)} "
+                    f"for multi-scale coherence preservation (C_parent ≥ α·ΣC_child)"
+                )
+
+        if violations:
+            return (False, f"U5 violated: {'; '.join(violations)}")
+
+        return (
+            True,
+            f"U5 satisfied: deep recursivity has scale stabilizers "
+            f"for multi-scale coherence preservation",
+        )
+
     @classmethod
     def validate(
         cls,
@@ -907,6 +1027,7 @@ def validate(
         - U2: Convergence & boundedness
         - U3: Resonant coupling
         - U4: Bifurcation dynamics
+        - U5: Multi-scale coherence
 
         Parameters
         ----------
@@ -960,6 +1081,11 @@ def validate(
         messages.append(f"U2-REMESH: {msg_remesh}")
         all_valid = all_valid and valid_remesh
 
+        # U5: Multi-scale coherence
+        valid_multiscale, msg_multiscale = cls.validate_multiscale_coherence(sequence)
+        messages.append(f"U5: {msg_multiscale}")
+        all_valid = all_valid and valid_multiscale
+
         return all_valid, messages
 
 

src/tnfr/operators/unified_grammar.py

@@ -1,14 +1,15 @@
 """Unified TNFR Grammar - Facade to GrammarValidator.
 
 This module provides a clean facade to the canonical grammar validation
-implemented in grammar.py. It exports the unified grammar constraints (U1-U4)
+implemented in grammar.py. It exports the unified grammar constraints (U1-U5)
 and the validator for use in tests and applications.
 
 All grammar rules derive inevitably from TNFR physics:
 - U1: STRUCTURAL INITIATION & CLOSURE
 - U2: CONVERGENCE & BOUNDEDNESS  
 - U3: RESONANT COUPLING
 - U4: BIFURCATION DYNAMICS (U4a: triggers, U4b: transformers)
+- U5: MULTI-SCALE COHERENCE
 
 References
 ----------
@@ -40,6 +41,8 @@
     COUPLING_RESONANCE,
     DESTABILIZERS,
     GENERATORS,
+    RECURSIVE_GENERATORS,
+    SCALE_STABILIZERS,
     STABILIZERS,
     TRANSFORMERS,
 )
@@ -52,7 +55,7 @@
     "UnifiedGrammarValidator",
     # Convenience function
     "validate_unified",
-    # Operator sets (U1-U4 categories)
+    # Operator sets (U1-U5 categories)
     "GENERATORS",
     "CLOSURES",
     "STABILIZERS",
@@ -61,14 +64,16 @@
     "BIFURCATION_TRIGGERS",
     "BIFURCATION_HANDLERS",
     "TRANSFORMERS",
+    "RECURSIVE_GENERATORS",
+    "SCALE_STABILIZERS",
 ]
 
 
 def validate_unified(
     sequence: List["Operator"],
     epi_initial: float = 0.0,
 ) -> bool:
-    """Validate sequence using unified TNFR grammar (U1-U4).
+    """Validate sequence using unified TNFR grammar (U1-U5).
 
     Convenience function that returns only boolean result.
     For detailed messages, use UnifiedGrammarValidator.validate().
@@ -83,7 +88,7 @@ def validate_unified(
     Returns
     -------
     bool
-        True if sequence satisfies all U1-U4 constraints
+        True if sequence satisfies all U1-U5 constraints
 
     Examples
     --------