Merge pull request #2806 from fermga/copilot/validate-sha-grammar-rules

SHA grammar validation: prohibit SHA→OZ and SHA→SHA, unlock 4 canonical variants

Author: fermga

src/tnfr/operators/canonical_patterns.py

@@ -29,6 +29,11 @@
     "THEORY_SYSTEM",
     "FULL_DEPLOYMENT",
     "MOD_STABILIZER",
+    # New variants unlocked by high → zero frequency transition
+    "CONTAINED_CRISIS",
+    "RESONANCE_PEAK_HOLD",
+    "MINIMAL_COMPRESSION",
+    "PHASE_LOCK",
 ]
 
 
@@ -190,6 +195,114 @@ class CanonicalSequence(NamedTuple):
 )
 
 
+# ============================================================================
+# New Canonical Variants: Direct high → zero Termination
+# Unlocked by frequency transition update allowing high → zero for SHA
+# ============================================================================
+
+CONTAINED_CRISIS = CanonicalSequence(
+    name="contained_crisis",
+    glyphs=[Glyph.AL, Glyph.EN, Glyph.IL, Glyph.OZ, Glyph.SHA],
+    pattern_type=StructuralPattern.THERAPEUTIC,
+    description=(
+        "Direct crisis containment: dissonance immediately preserved without processing. "
+        "OZ creates ΔNFR ↑ (tension, exploration), SHA immediately contains via νf → 0, "
+        "preserving tension in suspended state for later resolution. This is the canonical "
+        "'contained dissonance' pattern: trauma held safely, conflict postponed, tension "
+        "preserved. Essential for trauma first response, emergency pause, and protective freeze "
+        "when immediate processing would overwhelm the system."
+    ),
+    use_cases=[
+        "Trauma containment (immediate safety response without processing)",
+        "Crisis management (pause before system overwhelm)",
+        "Strategic hold (preserve tension for optimal timing)",
+        "Protective freeze (contain instability temporarily)",
+        "Emergency stop (halt exploration when risk detected)",
+    ],
+    domain="therapeutic",
+    references=(
+        "SHA Grammar Validation Issue: OZ → SHA as valid therapeutic pattern. "
+        "Frequency transition update: high → zero for containment/termination."
+    ),
+)
+
+RESONANCE_PEAK_HOLD = CanonicalSequence(
+    name="resonance_peak_hold",
+    glyphs=[Glyph.AL, Glyph.EN, Glyph.IL, Glyph.RA, Glyph.SHA],
+    pattern_type=StructuralPattern.RESONATE,
+    description=(
+        "Peak state preservation: amplified resonance frozen at maximum coherence. "
+        "RA amplifies network coherence (high C(t), increased νf), SHA suspends dynamics "
+        "(νf → 0) while preserving peak state, creating 'resonance memory'. Used for "
+        "flow state capture, optimal pattern preservation, and network snapshots. The "
+        "amplified coherence is held in latent form for later reactivation without decay."
+    ),
+    use_cases=[
+        "Flow state preservation (hold peak performance)",
+        "Peak coherence memory (capture optimal synchronization)",
+        "Network snapshot (freeze synchronized state)",
+        "Resonance consolidation (lock amplified pattern)",
+        "Optimal moment capture (preserve heightened state)",
+    ],
+    domain="cognitive",
+    references=(
+        "Frequency transition update: high → zero enables direct RA → SHA termination. "
+        "Memory consolidation pattern for peak states."
+    ),
+)
+
+MINIMAL_COMPRESSION = CanonicalSequence(
+    name="minimal_compression",
+    glyphs=[Glyph.AL, Glyph.EN, Glyph.IL, Glyph.NUL, Glyph.SHA],
+    pattern_type=StructuralPattern.COMPRESS,
+    description=(
+        "Compressed latency: structure reduced to essential form and preserved. "
+        "NUL concentrates EPI to core (contraction, high νf), SHA immediately freezes "
+        "minimal form (νf → 0), creating efficient storage. Distills pattern to fundamentals "
+        "then preserves in latent state. Used for information compression, core essence "
+        "extraction, and efficient memory storage of essential structure only."
+    ),
+    use_cases=[
+        "Information compression (minimal viable form)",
+        "Core essence extraction (distill to fundamentals)",
+        "Efficient storage (compact representation)",
+        "Essential pattern hold (preserve only critical structure)",
+        "Minimal memory (reduce before suspend)",
+    ],
+    domain="cognitive",
+    references=(
+        "Frequency transition update: high → zero enables direct NUL → SHA termination. "
+        "Compression-then-freeze pattern for efficient storage."
+    ),
+)
+
+PHASE_LOCK = CanonicalSequence(
+    name="phase_lock",
+    glyphs=[Glyph.AL, Glyph.EN, Glyph.IL, Glyph.OZ, Glyph.ZHIR, Glyph.SHA],
+    pattern_type=StructuralPattern.BIFURCATED,
+    description=(
+        "Phase transition hold: mutation immediately locked without stabilization. "
+        "OZ creates bifurcation threshold (ΔNFR ↑), ZHIR pivots phase θ (high νf), "
+        "SHA immediately locks new phase (νf → 0) before potential regression. Preserves "
+        "transformed state in latent form, preventing return to previous configuration. "
+        "Used for identity consolidation, paradigm shift memory, and transformation lock. "
+        "Simpler than full ZHIR → IL → SHA when immediate preservation desired."
+    ),
+    use_cases=[
+        "Identity shift hold (lock new configuration)",
+        "Phase memory (preserve transformed state)",
+        "Mutation consolidation (hold before integration)",
+        "Paradigm capture (freeze new perspective)",
+        "Transformation lock (prevent regression)",
+    ],
+    domain="cognitive",
+    references=(
+        "Frequency transition update: high → zero enables direct ZHIR → SHA termination. "
+        "Immediate phase lock pattern without intermediate stabilization."
+    ),
+)
+
+
 # ============================================================================
 # MOD_STABILIZER: Reusable Glyphic Macro
 # ============================================================================
@@ -231,6 +344,11 @@ class CanonicalSequence(NamedTuple):
         THEORY_SYSTEM,
         FULL_DEPLOYMENT,
         MOD_STABILIZER,
+        # New variants unlocked by high → zero frequency transition
+        CONTAINED_CRISIS,
+        RESONANCE_PEAK_HOLD,
+        MINIMAL_COMPRESSION,
+        PHASE_LOCK,
     ]
 }
 """Registry of all canonical operator sequences.

src/tnfr/operators/grammar.py

@@ -584,12 +584,48 @@ def _validate_transition(
         Frequency transitions are validated:
         - Valid transitions: Pass silently
         - Invalid transitions: Raise SequenceSyntaxError
+        
+        SHA (Silence) specific validations:
+        - SHA → OZ: Prohibited (silence followed by dissonance contradicts preservation)
+        - SHA → SHA: Prohibited (redundant silence without structural purpose)
         """
 
         # Only validate if prev is also a known operator
         if prev not in OPERATORS:
             return
 
+        # SHA-specific validations (R6: Silence operator compatibility)
+        if prev == SILENCE:
+            if curr == DISSONANCE:
+                # SHA → OZ: Silence followed by Dissonance is contradictory
+                # SHA reduces νf → 0 (preservation state)
+                # OZ increases ΔNFR (instability, exploration)
+                # Cannot introduce dissonance into a paused node
+                raise SequenceSyntaxError(
+                    index=index,
+                    token=token,
+                    message=(
+                        f"{operator_display_name(DISSONANCE)} invalid after {operator_display_name(SILENCE)}: "
+                        f"Silence (νf → 0) contradicts Dissonance (ΔNFR ↑). "
+                        f"Cannot introduce dissonance into paused node. "
+                        f"Use {operator_display_name(SILENCE)} → {operator_display_name(TRANSITION)} → {operator_display_name(DISSONANCE)} "
+                        f"or {operator_display_name(SILENCE)} → {operator_display_name(EMISSION)} → {operator_display_name(DISSONANCE)} for reactivation."
+                    ),
+                )
+            elif curr == SILENCE:
+                # SHA → SHA: Redundant silence without structural purpose
+                # If νf ≈ 0, second SHA has no effect
+                # Violates operator closure principle (each operator must transform)
+                raise SequenceSyntaxError(
+                    index=index,
+                    token=token,
+                    message=(
+                        f"Redundant {operator_display_name(SILENCE)} after {operator_display_name(SILENCE)}: "
+                        f"Consecutive silence operators serve no structural purpose. "
+                        f"Remove duplicate or insert transition operator."
+                    ),
+                )
+
         # R5: Validate structural frequency transitions using ONLY canonical TNFR physics
         freq_valid, freq_msg = validate_frequency_transition(prev, curr)
         if not freq_valid:
@@ -964,14 +1000,15 @@ class StructuralPattern(Enum):
 # Frequency compatibility: operators with harmonic frequencies can transition
 # Valid transitions preserve structural coherence:
 # - high ↔ medium: High energy can stabilize or stabilized can amplify
+# - high → zero: High energy can pause (containment, closure) - SHA as terminator
 # - medium ↔ zero: Stabilized can pause or resume from pause
 # - high ↔ high: High energy can chain directly
 # - zero → medium: Gradual reactivation from silence (structurally coherent)
 # 
 # Invalid: zero → high (violates structural continuity - cannot jump from pause
 # to high energy without intermediate stabilization)
 FREQUENCY_TRANSITIONS: dict[str, set[str]] = {
-    "high": {"high", "medium"},
+    "high": {"high", "medium", "zero"},  # Allow high → zero for SHA termination (OZ → SHA valid)
     "medium": {"high", "medium", "zero"},
     "zero": {"medium"},  # Must transition through medium before high (structural coherence)
 }
@@ -999,12 +1036,17 @@ def validate_frequency_transition(
     -----
     Structural frequency transitions follow TNFR canonical rules:
     - High ↔ Medium: Bidirectional, natural energy exchange
+    - High → Zero: High energy can pause (containment, closure via SHA terminator)
     - Medium ↔ Zero: Stabilization can pause, pause can resume
     - High ↔ High: High energy operators can chain directly
     - **Invalid**: Zero → High without Medium intermediary
 
-    This validation generates warnings (not errors) to maintain flexibility while
-    alerting users to potentially incoherent structural transitions.
+    Special case: OZ → SHA (dissonance → silence) is valid and represents
+    contained dissonance, postponed conflict, or preserved tension for later processing.
+    This is a canonical therapeutic and crisis management pattern.
+
+    This validation generates errors (not warnings) to enforce structural coherence
+    and prevent incoherent state transitions.
     """
     # Get frequency levels for both operators
     prev_freq = STRUCTURAL_FREQUENCIES.get(prev_operator)