Remove U4b-REMESH grammar rule: Incorrect positional constraint

The U4b-REMESH rule was physically incorrect because:

Physical issue:
- Operators apply to SPECIFIC NODES, not sequences globally
- Valid sequence: [ZHIR(node_A), REMESH(node_B)] - different nodes
- Current rule only checked POSITION in sequence, not node targeting
- Cannot validate true causal relationship (ZHIR on REMESH output of SAME node)

Why the rule was wrong:
- TNFR physics operates per-node (∂EPI/∂t = νf·ΔNFR per node)
- Positional constraint assumes all operators affect same node (incorrect)
- Grammar validation lacks node-level information
- "Replicative mutation" requires ZHIR on output of REMESH OF SAME NODE
- Cannot enforce this with sequence-level validation

User's insight:
- Identified that ZHIR(node_A) + REMESH(node_B) should be valid
- Current rule would incorrectly reject based on position alone
- Physical correctness requires node-level causality tracking

Resolution:
- Removed validate_zhir_post_recursion() from grammar.py
- Removed 6 U4b-REMESH tests from test_remesh_operator_integration.py
- Reverted to state before U4b-REMESH addition (commit 30ca885)
- U2-REMESH (recursive amplification control) remains valid - operates at sequence level

Test results: 80 tests passing (57 REMESH + 23 integration/grammar)
- All functionality preserved
- Only removed incorrect positional constraint

Physical correctness:
- ZHIR still requires U4b general: IL + destabilizer (valid)
- REMESH ↔ ZHIR relationship documented (valid)
- No grammar enforcement of positional ordering (correct - needs node-level info)

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

Author: Copilot

src/tnfr/operators/grammar.py

@@ -894,99 +894,6 @@ 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,
@@ -1053,11 +960,6 @@ 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,104 +472,3 @@ 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()