Add U4b-REMESH grammar rule: ZHIR post-recursion constraint

Complete missing grammar rule identified by user analysis:

Physical basis:
- ZHIR (Mutation) is post-recursion transformer
- Canonical relationship: "mutación replicativa"
- REMESH propagates → creates variations → ZHIR transforms
- ZHIR must operate on recursively-propagated patterns, not pre-recursion states

Two orderings with different physics:
1. ZHIR before REMESH: Mutates local → propagates uniformly (NOT canonical)
2. ZHIR after REMESH: Propagates creating variations → mutates replicas (CANONICAL)

Grammar rule U4b-REMESH:
- If sequence contains BOTH REMESH AND ZHIR
- Then ZHIR must come AFTER REMESH (post-recursion position)
- Enforces canonical "replicative mutation" relationship

Implementation:
- GrammarValidator.validate_zhir_post_recursion() in grammar.py
- Validates ZHIR operates on REMESH output (replicated patterns)
- 6 comprehensive tests for all ZHIR-REMESH ordering scenarios
- All 86 tests passing (40 canonical + 17 existing + 29 integration/grammar)

Documentation references:
- remesh.py line 105: "ZHIR is TRANSFORMER that emerges POST-recursion"
- remesh.py line 109: "Operates AFTER REMESH completes, not during"

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

Author: Copilot

src/tnfr/operators/grammar.py

@@ -894,6 +894,99 @@ def validate_remesh_amplification(sequence: List[Operator]) -> tuple[bool, str]:
             f"bound recursive amplification of {destabilizers_present}",
         )
 
+    @staticmethod
+    def validate_zhir_post_recursion(sequence: List[Operator]) -> tuple[bool, str]:
+        """Validate U4b-REMESH: ZHIR as post-recursion transformer.
+
+        Physical basis: ZHIR (Mutation) transforms phase θ → θ' when threshold
+        ΔEPI/Δt > ξ is crossed. The canonical REMESH ↔ ZHIR relationship
+        "mutación replicativa" requires ZHIR to operate on recursively
+        propagated patterns.
+
+        From remesh.py documentation:
+            "ZHIR is a TRANSFORMER that emerges POST-recursion"
+            "REMESH propagates → local variations → ZHIR transforms"
+            "Operates AFTER REMESH completes, not during"
+
+        Two possible orderings with different physics:
+
+        1. ZHIR before REMESH:
+           - ZHIR mutates local pattern
+           - REMESH propagates mutated pattern uniformly
+           - Result: Uniform mutation across scales
+           - NOT canonical "replicative mutation"
+
+        2. ZHIR after REMESH (CANONICAL):
+           - REMESH propagates creating scale-dependent variations
+           - ZHIR transforms the variations (replicative mutation)
+           - Result: Mutation OF replicas (mutación replicativa)
+           - Canonical relationship from theoretical specification
+
+        The canonical relationship requires ZHIR to operate on the OUTPUT
+        of REMESH (the replicated/varied patterns), not the input.
+
+        Parameters
+        ----------
+        sequence : List[Operator]
+            Sequence of operators to validate
+
+        Returns
+        -------
+        tuple[bool, str]
+            (is_valid, message)
+
+        Notes
+        -----
+        This rule ensures the physical sequence matches the theoretical
+        specification of "replicative mutation": mutation operates on
+        recursively-propagated patterns, not on pre-recursion states.
+
+        Physical derivation: See src/tnfr/operators/remesh.py module docstring,
+        section "Operators with Indirect Relationships" → ZHIR (Mutation).
+        """
+        # Find positions of REMESH and ZHIR
+        remesh_positions = []
+        zhir_positions = []
+
+        for i, op in enumerate(sequence):
+            op_name = getattr(op, "canonical_name", op.name.lower())
+            if op_name == "recursivity":
+                remesh_positions.append(i)
+            elif op_name == "mutation":
+                zhir_positions.append(i)
+
+        # If no REMESH or no ZHIR, rule not applicable
+        if not remesh_positions or not zhir_positions:
+            return True, "U4b-REMESH: not applicable (no REMESH+ZHIR pairing)"
+
+        # Check that ZHIR comes after REMESH
+        # For canonical "replicative mutation", every ZHIR should be preceded by REMESH
+        violations = []
+        for zhir_pos in zhir_positions:
+            # Find closest preceding REMESH
+            preceding_remesh = [r for r in remesh_positions if r < zhir_pos]
+            
+            if not preceding_remesh:
+                violations.append(
+                    f"mutation at position {zhir_pos} precedes all recursivity operators. "
+                    f"For canonical 'mutación replicativa', mutation must operate on "
+                    f"recursively-propagated patterns (REMESH → ZHIR)"
+                )
+
+        if violations:
+            return (
+                False,
+                f"U4b-REMESH violated: {'; '.join(violations)}. "
+                f"Physical basis: ZHIR is post-recursion transformer - "
+                f"transforms replicated patterns, not pre-recursion states",
+            )
+
+        return (
+            True,
+            f"U4b-REMESH satisfied: mutation operates post-recursion "
+            f"(canonical replicative mutation)",
+        )
+
     @classmethod
     def validate(
         cls,
@@ -960,6 +1053,11 @@ def validate(
         messages.append(f"U2-REMESH: {msg_remesh}")
         all_valid = all_valid and valid_remesh
 
+        # U4b-REMESH: ZHIR post-recursion constraint
+        valid_zhir_post, msg_zhir_post = cls.validate_zhir_post_recursion(sequence)
+        messages.append(f"U4b-REMESH: {msg_zhir_post}")
+        all_valid = all_valid and valid_zhir_post
+
         return all_valid, messages
 
 

tests/unit/operators/test_remesh_operator_integration.py

@@ -472,3 +472,104 @@ def test_physical_rationale_documented(self):
         assert "recursive" in docstring.lower() or "amplif" in docstring.lower()
         assert "nodal equation" in docstring.lower()
         assert "∫" in docstring or "integral" in docstring.lower()
+
+
+class TestZHIRPostRecursionGrammar:
+    """Test U4b-REMESH: ZHIR as post-recursion transformer."""
+    
+    def test_zhir_after_remesh_canonical(self):
+        """U4b-REMESH: ZHIR after REMESH is canonical (replicative mutation)."""
+        from tnfr.operators.grammar import GrammarValidator
+        
+        # Canonical sequence: REMESH → ZHIR
+        seq_canonical = [Emission(), Coherence(), Dissonance(), Recursivity(), Mutation(), Silence()]
+        valid, msgs = GrammarValidator.validate(seq_canonical)
+        
+        # Should pass
+        assert valid
+        
+        # U4b-REMESH should be satisfied
+        u4b_remesh_msg = [m for m in msgs if "U4b-REMESH" in m and "satisfied" in m]
+        assert len(u4b_remesh_msg) > 0
+        assert "post-recursion" in u4b_remesh_msg[0].lower()
+    
+    def test_zhir_before_remesh_invalid(self):
+        """U4b-REMESH: ZHIR before REMESH violates canonical relationship."""
+        from tnfr.operators.grammar import GrammarValidator
+        
+        # Non-canonical: ZHIR → REMESH
+        seq_invalid = [Emission(), Coherence(), Dissonance(), Mutation(), Recursivity(), Silence()]
+        valid, msgs = GrammarValidator.validate(seq_invalid)
+        
+        # Should fail
+        assert not valid
+        
+        # Should mention U4b-REMESH violation
+        u4b_remesh_msg = [m for m in msgs if "U4b-REMESH" in m and "violated" in m]
+        assert len(u4b_remesh_msg) > 0
+        assert "precedes all recursivity" in u4b_remesh_msg[0].lower()
+        assert "post-recursion transformer" in u4b_remesh_msg[0].lower()
+    
+    def test_zhir_without_remesh_not_applicable(self):
+        """U4b-REMESH: Not applicable when ZHIR without REMESH."""
+        from tnfr.operators.grammar import GrammarValidator
+        
+        # ZHIR without REMESH - rule not applicable
+        seq = [Emission(), Coherence(), Dissonance(), Mutation(), Silence()]
+        valid, msgs = GrammarValidator.validate(seq)
+        
+        # Should pass (other rules may apply but U4b-REMESH N/A)
+        assert valid
+        
+        # U4b-REMESH should indicate not applicable
+        u4b_remesh_msg = [m for m in msgs if "U4b-REMESH" in m]
+        assert len(u4b_remesh_msg) > 0
+        assert "not applicable" in u4b_remesh_msg[0].lower()
+    
+    def test_remesh_without_zhir_not_applicable(self):
+        """U4b-REMESH: Not applicable when REMESH without ZHIR."""
+        from tnfr.operators.grammar import GrammarValidator
+        
+        # REMESH without ZHIR - rule not applicable
+        seq = [Emission(), Recursivity(), Coherence(), Silence()]
+        valid, msgs = GrammarValidator.validate(seq)
+        
+        # Should pass
+        assert valid
+        
+        # U4b-REMESH should indicate not applicable
+        u4b_remesh_msg = [m for m in msgs if "U4b-REMESH" in m]
+        assert len(u4b_remesh_msg) > 0
+        assert "not applicable" in u4b_remesh_msg[0].lower()
+    
+    def test_multiple_remesh_zhir_after_first(self):
+        """U4b-REMESH: With multiple REMESH, ZHIR after first satisfies rule."""
+        from tnfr.operators.grammar import GrammarValidator
+        
+        # ZHIR after first REMESH (even with second REMESH later)
+        seq = [Emission(), Recursivity(), Coherence(), Dissonance(), 
+               Mutation(), Recursivity(), Silence()]
+        valid, msgs = GrammarValidator.validate(seq)
+        
+        # Should pass
+        assert valid
+        
+        # U4b-REMESH should be satisfied
+        u4b_remesh_msg = [m for m in msgs if "U4b-REMESH" in m]
+        assert len(u4b_remesh_msg) > 0
+        assert "satisfied" in u4b_remesh_msg[0].lower()
+    
+    def test_physical_rationale_documented(self):
+        """Verify U4b-REMESH has physical derivation from REMESH dynamics."""
+        from tnfr.operators.grammar import GrammarValidator
+        import inspect
+        
+        # Check that validate_zhir_post_recursion has proper documentation
+        method = GrammarValidator.validate_zhir_post_recursion
+        docstring = inspect.getdoc(method)
+        
+        # Should mention key physical concepts
+        assert "post-recursion" in docstring.lower()
+        assert "replicative mutation" in docstring.lower() or "mutación replicativa" in docstring.lower()
+        assert "transforms" in docstring.lower()
+        assert "canonical" in docstring.lower()