Add U2-REMESH grammar rule: Recursive amplification control

Implement physics-derived grammar limitation for REMESH operator:

Physical basis:
- REMESH temporal coupling (1-α)·EPI_now + α·EPI_past creates feedback
- Amplifies structural changes through recursive propagation
- REMESH + destabilizers → unbounded growth without stabilizers
- ∫ νf · ΔNFR dt → ∞ (divergence) requires control

Grammar rule U2-REMESH:
- If sequence contains BOTH REMESH AND destabilizers {VAL, OZ, ZHIR}
- Then MUST contain stabilizers {IL, THOL}
- Prevents: Recursive expansion, recursive bifurcation, replicative mutation

Specific combinations:
- REMESH + VAL: Recursive expansion needs coherence stabilization
- REMESH + OZ: Recursive bifurcation needs self-organization handlers
- REMESH + ZHIR: Replicative mutation needs coherence consolidation

Implementation:
- GrammarValidator.validate_remesh_amplification() in grammar.py
- Called in unified validation pipeline
- 6 comprehensive tests validating physics-based constraints
- All 80 tests passing (40 canonical + 17 existing + 17 integration + 6 grammar)

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

Author: Copilot

src/tnfr/operators/grammar.py

@@ -804,6 +804,96 @@ def validate_transformer_context(sequence: List[Operator]) -> tuple[bool, str]:
 
         return (True, f"U4b satisfied: transformers have proper context")
 
+    @staticmethod
+    def validate_remesh_amplification(sequence: List[Operator]) -> tuple[bool, str]:
+        """Validate U2-REMESH: Recursive amplification control.
+
+        Physical basis: REMESH implements temporal coupling EPI(t) ↔ EPI(t-τ)
+        which creates feedback that amplifies structural changes. When combined
+        with destabilizers, this can cause unbounded growth.
+
+        From integrated nodal equation:
+            EPI(t_f) = EPI(t_0) + ∫_{t_0}^{t_f} νf·ΔNFR dτ
+
+        REMESH temporal mixing:
+            EPI_mixed = (1-α)·EPI_now + α·EPI_past
+
+        Without stabilizers:
+            REMESH + destabilizers → recursive amplification
+            → ∫ νf·ΔNFR dt → ∞ (feedback loop)
+            → System fragments
+
+        With stabilizers:
+            IL or THOL provides negative feedback
+            → Bounded recursive evolution
+            → ∫ νf·ΔNFR dt < ∞
+
+        Specific combinations requiring stabilizers:
+            - REMESH + VAL: Recursive expansion needs coherence stabilization
+            - REMESH + OZ: Recursive bifurcation needs self-organization handlers
+            - REMESH + ZHIR: Replicative mutation needs coherence consolidation
+
+        Parameters
+        ----------
+        sequence : List[Operator]
+            Sequence of operators to validate
+
+        Returns
+        -------
+        tuple[bool, str]
+            (is_valid, message)
+
+        Notes
+        -----
+        This rule is DISTINCT from general U2 (convergence). While U2 checks
+        for destabilizers needing stabilizers, U2-REMESH specifically addresses
+        REMESH's amplification property: it multiplies the effect of destabilizers
+        through recursive feedback across temporal/spatial scales.
+
+        Physical derivation: See src/tnfr/operators/remesh.py module docstring,
+        section "Grammar Implications from Physical Analysis" → U2: CONVERGENCE.
+        """
+        # Check if sequence contains REMESH
+        has_remesh = any(
+            getattr(op, "canonical_name", op.name.lower()) == "recursivity"
+            for op in sequence
+        )
+
+        if not has_remesh:
+            return True, "U2-REMESH: not applicable (no recursivity present)"
+
+        # Check for destabilizers
+        destabilizers_present = [
+            getattr(op, "canonical_name", op.name.lower())
+            for op in sequence
+            if getattr(op, "canonical_name", op.name.lower()) in DESTABILIZERS
+        ]
+
+        if not destabilizers_present:
+            return True, "U2-REMESH: satisfied (no destabilizers to amplify)"
+
+        # Check for stabilizers
+        stabilizers_present = [
+            getattr(op, "canonical_name", op.name.lower())
+            for op in sequence
+            if getattr(op, "canonical_name", op.name.lower()) in STABILIZERS
+        ]
+
+        if not stabilizers_present:
+            return (
+                False,
+                f"U2-REMESH violated: recursivity amplifies destabilizers "
+                f"{destabilizers_present} via recursive feedback. "
+                f"Integral ∫νf·ΔNFR dt may diverge (unbounded growth). "
+                f"Required: {sorted(STABILIZERS)} to bound recursive amplification",
+            )
+
+        return (
+            True,
+            f"U2-REMESH satisfied: stabilizers {stabilizers_present} "
+            f"bound recursive amplification of {destabilizers_present}",
+        )
+
     @classmethod
     def validate(
         cls,
@@ -865,6 +955,11 @@ def validate(
         messages.append(f"U4b: {msg_context}")
         all_valid = all_valid and valid_context
 
+        # U2-REMESH: Recursive amplification control
+        valid_remesh, msg_remesh = cls.validate_remesh_amplification(sequence)
+        messages.append(f"U2-REMESH: {msg_remesh}")
+        all_valid = all_valid and valid_remesh
+
         return all_valid, messages
 
 

tests/unit/operators/test_remesh_operator_integration.py

@@ -369,3 +369,106 @@ def test_similar_patterns_after_same_sequence(self):
 
         similarity = structural_similarity(epi1, epi2)
         assert similarity > 0.8  # Should remain similar
+
+
+class TestREMESHGrammarLimitations:
+    """Test REMESH-specific grammar limitations derived from physics."""
+    
+    def test_remesh_amplification_requires_stabilizer_with_VAL(self):
+        """U2-REMESH: REMESH + VAL requires stabilizer (recursive expansion)."""
+        from tnfr.operators.grammar import GrammarValidator
+        
+        # REMESH + VAL without stabilizer should violate U2-REMESH
+        seq_invalid = [Emission(), Recursivity(), Expansion(), Silence()]
+        valid, msgs = GrammarValidator.validate(seq_invalid)
+        
+        # Should fail
+        assert not valid
+        
+        # Should mention U2-REMESH violation
+        u2_remesh_msg = [m for m in msgs if "U2-REMESH" in m and "violated" in m]
+        assert len(u2_remesh_msg) > 0
+        assert "recursive amplification" in u2_remesh_msg[0].lower()
+    
+    def test_remesh_amplification_satisfied_with_stabilizer(self):
+        """U2-REMESH: REMESH + VAL + IL satisfies grammar."""
+        from tnfr.operators.grammar import GrammarValidator
+        
+        # REMESH + VAL + IL should satisfy U2-REMESH
+        seq_valid = [Emission(), Recursivity(), Expansion(), Coherence(), Silence()]
+        valid, msgs = GrammarValidator.validate(seq_valid)
+        
+        # Should pass
+        assert valid
+        
+        # U2-REMESH should be satisfied
+        u2_remesh_msg = [m for m in msgs if "U2-REMESH" in m and "satisfied" in m]
+        assert len(u2_remesh_msg) > 0
+    
+    def test_remesh_amplification_requires_stabilizer_with_OZ(self):
+        """U2-REMESH: REMESH + OZ requires stabilizer (recursive bifurcation)."""
+        from tnfr.operators.grammar import GrammarValidator
+        
+        # REMESH + OZ without stabilizer should violate U2-REMESH
+        seq_invalid = [Emission(), Recursivity(), Dissonance(), Silence()]
+        valid, msgs = GrammarValidator.validate(seq_invalid)
+        
+        # Should fail
+        assert not valid
+        
+        # Should mention dissonance amplification
+        u2_remesh_msg = [m for m in msgs if "U2-REMESH" in m and "violated" in m]
+        assert len(u2_remesh_msg) > 0
+        assert "dissonance" in u2_remesh_msg[0].lower()
+    
+    def test_remesh_without_destabilizer_not_applicable(self):
+        """U2-REMESH: Not applicable when REMESH has no destabilizers."""
+        from tnfr.operators.grammar import GrammarValidator
+        
+        # REMESH without destabilizers - U2-REMESH not applicable
+        seq = [Emission(), Recursivity(), Coherence(), Silence()]
+        valid, msgs = GrammarValidator.validate(seq)
+        
+        # Should pass
+        assert valid
+        
+        # U2-REMESH should indicate not applicable or satisfied
+        u2_remesh_msg = [m for m in msgs if "U2-REMESH" in m]
+        assert len(u2_remesh_msg) > 0
+        assert ("not applicable" in u2_remesh_msg[0].lower() or 
+                "satisfied" in u2_remesh_msg[0].lower())
+    
+    def test_destabilizer_without_remesh_uses_general_U2(self):
+        """General U2 applies when destabilizers present without REMESH."""
+        from tnfr.operators.grammar import GrammarValidator
+        
+        # VAL without REMESH - general U2 applies, not U2-REMESH
+        seq = [Emission(), Expansion(), Silence()]
+        valid, msgs = GrammarValidator.validate(seq)
+        
+        # Should fail on general U2
+        assert not valid
+        
+        # U2 should be violated
+        u2_msg = [m for m in msgs if m.startswith("U2:") and "violated" in m]
+        assert len(u2_msg) > 0
+        
+        # U2-REMESH should not be applicable
+        u2_remesh_msg = [m for m in msgs if "U2-REMESH" in m]
+        assert len(u2_remesh_msg) > 0
+        assert "not applicable" in u2_remesh_msg[0].lower()
+    
+    def test_physical_rationale_documented(self):
+        """Verify U2-REMESH has physical derivation from nodal equation."""
+        from tnfr.operators.grammar import GrammarValidator
+        import inspect
+        
+        # Check that validate_remesh_amplification has proper documentation
+        method = GrammarValidator.validate_remesh_amplification
+        docstring = inspect.getdoc(method)
+        
+        # Should mention key physical concepts
+        assert "temporal coupling" in docstring.lower()
+        assert "recursive" in docstring.lower() or "amplif" in docstring.lower()
+        assert "nodal equation" in docstring.lower()
+        assert "∫" in docstring or "integral" in docstring.lower()