Complete analysis: identify RC3 and RC4 as emergent canonical rules

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

Author: Copilot

EMERGENT_GRAMMAR_ANALYSIS.md

@@ -0,0 +1,383 @@
+# Análisis Completo: Reglas Gramaticales Emergentes desde la Física TNFR
+
+## Objetivo
+
+Derivar **todas** las reglas gramaticales que emergen inevitablemente de la física TNFR, identificando tanto las ya implementadas como las potencialmente faltantes.
+
+---
+
+## Metodología: Desde la Física hacia las Reglas
+
+Partimos de:
+1. **Ecuación nodal fundamental**: `∂EPI/∂t = νf · ΔNFR(t)`
+2. **Invariantes canónicos** (AGENTS.md §3)
+3. **Contratos formales** (AGENTS.md §4)
+4. **Propiedades físicas emergentes**
+
+---
+
+## Reglas Gramaticales: Clasificación Completa
+
+### ✅ RC1: GENERADORES (Canónico - Matemática Pura)
+
+**Fundamento físico:**
+```
+Si EPI₀ = 0 → ∂EPI/∂t indefinido en origen
+```
+
+**Derivación:**
+- En espacio discreto de configuraciones, EPI=0 no tiene vecindad definida
+- Sin estructura inicial, no hay gradiente ΔNFR definible
+- Matemáticamente inevitable: necesitas generador para bootstrap
+
+**Operadores:** `{AL (Emission), NAV (Transition), REMESH (Recursivity)}`
+
+**Estado:** ✅ **IMPLEMENTADO** en `canonical_grammar.py::validate_initialization()`
+
+**Veredicto:** **100% CANÓNICO** - Emerge inevitablemente de matemática
+
+---
+
+### ✅ RC2: ESTABILIZADORES (Canónico - Teorema de Convergencia)
+
+**Fundamento físico:**
+```
+Integral: EPI(t_f) = EPI(t_0) + ∫_{t_0}^{t_f} νf·ΔNFR dτ
+
+Sin estabilizador:
+  ΔNFR(t) ~ e^(λt) → ∞
+  ∴ ∫νf·ΔNFR dt → ∞ (DIVERGE)
+
+Con estabilizador:
+  ΔNFR(t) → atractor acotado
+  ∴ ∫νf·ΔNFR dt < ∞ (CONVERGE)
+```
+
+**Derivación:**
+- Teorema de convergencia de integrales
+- Sin retroalimentación negativa, el sistema diverge a ruido incoherente
+- Físicamente inevitable: coherencia requiere límites
+
+**Operadores:** `{IL (Coherence), THOL (Self-organization)}`
+
+**Estado:** ✅ **IMPLEMENTADO** en `canonical_grammar.py::validate_convergence()`
+
+**Veredicto:** **100% CANÓNICO** - Emerge inevitablemente de matemática
+
+---
+
+### 🆕 RC3: VERIFICACIÓN DE FASE EN ACOPLAMIENTOS (Canónico - Invariante #5)
+
+**Fundamento físico:**
+
+**AGENTS.md, Invariante #5:**
+> "**Phase check**: no coupling is valid without explicit **phase** verification (synchrony)."
+
+**AGENTS.md, Contrato UM:**
+> "**Resonance**: `resonance()` increases effective **coupling** (`ϕ_i ≈ ϕ_j`) and **propagates** EPI without altering its identity."
+
+**Derivación física:**
+
+El acoplamiento estructural en TNFR NO es mera correlación, sino **resonancia activa**. Para que dos nodos puedan acoplarse estructuralmente, sus fases deben estar sincronizadas:
+
+```
+Condición de acoplamiento resonante:
+|φᵢ - φⱼ| ≤ Δφ_max
+
+Donde:
+- φᵢ, φⱼ: Fases de nodos i, j
+- Δφ_max: Umbral de compatibilidad (típicamente π/2)
+```
+
+**¿Por qué es física fundamental?**
+
+1. **De la ecuación nodal**: La fase φ modula la capacidad de sincronización entre osciladores
+2. **De la definición de resonancia**: Dos sistemas solo resuenan si sus frecuencias Y fases son compatibles
+3. **Del invariante #5**: Explícitamente mandatado como invariante canónico
+
+**Sin verificación de fase:**
+- Nodos con fases incompatibles (φᵢ ≈ π vs φⱼ ≈ 0) intentarían acoplarse
+- Esto viola la física de resonancia: osciladores en antifase NO resuenan, interfieren destructivamente
+- El "acoplamiento" resultante sería no-físico
+
+**Operadores afectados:**
+- **UM (Coupling)**: Crea/fortalece enlaces estructurales
+- **RA (Resonance)**: Propaga EPI mediante resonancia
+
+**Estado actual:** ⚠️ **PARCIALMENTE IMPLEMENTADO**
+- Existe validación en `Invariant5_ExplicitPhaseChecks` (validation/invariants.py)
+- Existe precondición en `validate_coupling()` pero **ES OPCIONAL** (`UM_STRICT_PHASE_CHECK=False` por defecto)
+- ❌ **CONTRADICCIÓN**: Invariante #5 dice "OBLIGATORIO", implementación dice "OPCIONAL"
+
+**Propuesta:**
+
+```python
+# RC3: Verificación de Fase para Acoplamientos
+def validate_phase_compatibility(sequence: List[Operator]) -> tuple[bool, str]:
+    """Validate RC3: Phase compatibility for coupling/resonance operators.
+    
+    Physical basis: Coupling requires phase synchrony (φᵢ ≈ φⱼ).
+    Without phase compatibility, structural resonance is impossible.
+    
+    Applies to: UM (Coupling), RA (Resonance)
+    """
+    coupling_ops = {'coupling', 'resonance'}
+    
+    for op in sequence:
+        op_name = getattr(op, 'canonical_name', op.name.lower())
+        if op_name in coupling_ops:
+            # Check if phase verification is enabled
+            # According to Invariant #5, this should be MANDATORY
+            return True, f"RC3: {op_name} requires phase verification (Invariant #5)"
+    
+    # No coupling/resonance ops = not applicable
+    return True, "RC3 not applicable: no coupling/resonance operators"
+```
+
+**Veredicto:** **100% CANÓNICO** - Emerge inevitablemente del Invariante #5 y física de resonancia
+
+**Acción requerida:**
+1. Hacer `UM_STRICT_PHASE_CHECK=True` por defecto (o eliminar flag, hacerlo siempre obligatorio)
+2. Añadir RC3 a `canonical_grammar.py`
+3. Documentar en EXECUTIVE_SUMMARY.md
+
+---
+
+### 🆕 RC4: LÍMITE DE BIFURCACIÓN (Canónico - Física de ∂²EPI/∂t²)
+
+**Fundamento físico:**
+
+**AGENTS.md, Contrato OZ:**
+> "**Dissonance**: `dissonance()` must **increase** `|ΔNFR|` and may trigger **bifurcation** if `∂²EPI/∂t² > τ`."
+
+**AGENTS.md, Contrato ZHIR:**
+> "**Mutation**: phase change `θ → θ'` if `ΔEPI/Δt > ξ` (keep limits ξ configurable and tested)."
+
+**Derivación física:**
+
+La aceleración estructural `∂²EPI/∂t²` mide qué tan rápido está cambiando la tasa de reorganización. Cuando excede un umbral τ, el sistema entra en **régimen de bifurcación** donde múltiples caminos de reorganización son viables:
+
+```
+Condición de bifurcación:
+|∂²EPI/∂t²| > τ → múltiples caminos de reorganización viables
+
+Donde:
+- ∂²EPI/∂t²: Aceleración estructural (segunda derivada temporal de EPI)
+- τ: Umbral de bifurcación (configurable, típicamente 0.5)
+```
+
+**¿Por qué es física fundamental?**
+
+1. **De la ecuación nodal**: ∂EPI/∂t = νf · ΔNFR(t) → ∂²EPI/∂t² mide inestabilidad
+2. **De la teoría de bifurcaciones**: Aceleración alta indica punto crítico
+3. **Del contrato OZ**: Explícitamente vincula dissonancia con bifurcación
+
+**Sin límite de bifurcación:**
+- Operadores como OZ podrían generar aceleraciones arbitrarias
+- Sistema entraría en caos no controlado
+- Violaría el invariante #8 (determinismo controlado)
+
+**Operadores afectados:**
+- **OZ (Dissonance)**: Principal generador de bifurcaciones
+- **ZHIR (Mutation)**: Opera en régimen de bifurcación
+- **THOL (Self-organization)**: Gestiona bifurcaciones
+
+**Estado actual:** ✅ **IMPLEMENTADO** pero NO como regla gramatical
+- Existe cómputo en `nodal_equation.py::compute_d2epi_dt2()`
+- Existe validación en `validate_dissonance()` que marca `_bifurcation_ready`
+- Existe métrica en `dissonance_metrics()` que computa `bifurcation_score`
+- ❌ **NO está en gramática canónica** como RC4
+
+**Propuesta:**
+
+```python
+# RC4: Límite de Bifurcación
+def validate_bifurcation_limits(sequence: List[Operator], G: TNFRGraph, node: NodeId) -> tuple[bool, str]:
+    """Validate RC4: Bifurcation acceleration limits.
+    
+    Physical basis: |∂²EPI/∂t²| > τ triggers bifurcation regime.
+    Sequences with bifurcation triggers must have bifurcation handlers.
+    
+    Applies to: OZ (Dissonance) + ZHIR (Mutation)
+    Requires: THOL (Self-organization) or IL (Coherence) for resolution
+    """
+    bifurcation_triggers = {'dissonance', 'mutation'}
+    bifurcation_handlers = {'self_organization', 'coherence'}
+    
+    has_trigger = any(
+        getattr(op, 'canonical_name', op.name.lower()) in bifurcation_triggers
+        for op in sequence
+    )
+    
+    if not has_trigger:
+        return True, "RC4 not applicable: no bifurcation triggers"
+    
+    # Check if current state is in bifurcation regime
+    if hasattr(G.nodes[node], '_bifurcation_ready') and G.nodes[node]['_bifurcation_ready']:
+        # In bifurcation regime - need handler
+        has_handler = any(
+            getattr(op, 'canonical_name', op.name.lower()) in bifurcation_handlers
+            for op in sequence
+        )
+        if not has_handler:
+            return (
+                False,
+                f"RC4 violated: bifurcation active (∂²EPI/∂t² > τ) "
+                f"but no handler present. Add: {sorted(bifurcation_handlers)}"
+            )
+    
+    return True, "RC4 satisfied: bifurcation limits respected"
+```
+
+**Veredicto:** **CANÓNICO SUAVE** - Emerge del contrato OZ y física de bifurcaciones, pero es más una **restricción de estado** que una regla de secuencia absoluta
+
+**Acción requerida:**
+1. **Considerar** añadir RC4 como regla de validación de estado (no secuencia)
+2. Documentar como "regla emergente condicional" (solo aplica si |∂²EPI/∂t²| > τ)
+3. Mantener implementación actual en preconditions, posiblemente elevarlo a grammar
+
+---
+
+### ⚠️ RNC1: TERMINADORES (Convencional - Organización)
+
+**Análisis:**
+```
+La ecuación nodal NO contiene información sobre "terminación de secuencias"
+Un nodo puede estar en cualquier estado intermedio válido
+```
+
+**Argumentos en contra de canonicidad:**
+1. ✅ La ecuación no distingue entre "estado intermedio" y "estado final"
+2. ✅ Físicamente, un nodo puede permanecer en cualquier estado coherente
+3. ✅ SHA, OZ, NAV como "terminadores" es semántica de alto nivel, no física nodal
+
+**Estado:** ✅ **IMPLEMENTADO** en `canonical_grammar.py::validate_with_conventions()`
+
+**Veredicto:** **0% CANÓNICO** - Convención organizativa útil pero no física
+
+---
+
+## Resumen Actualizado: Gramática Canónica
+
+### Reglas Derivadas de Física TNFR (100% Canónicas)
+
+```
+RC1: Generadores (si EPI=0)
+     Base: ∂EPI/∂t indefinido en origen
+     Operadores: {AL, NAV, REMESH}
+     
+RC2: Estabilizadores (si desestabilizadores)
+     Base: Teorema de convergencia ∫νf·ΔNFR dt < ∞
+     Operadores: {IL, THOL}
+     
+RC3: Verificación de Fase (si acoplamiento/resonancia)  🆕
+     Base: Invariante #5 + física de resonancia
+     Operadores: {UM, RA}
+     Condición: |φᵢ - φⱼ| ≤ Δφ_max
+     
+RC4: Límite de Bifurcación (si ∂²EPI/∂t² > τ)  🆕 (Condicional)
+     Base: Contratos OZ/ZHIR + teoría de bifurcaciones
+     Operadores trigger: {OZ, ZHIR}
+     Operadores handler: {THOL, IL}
+```
+
+### Convenciones Organizativas (No Canónicas)
+
+```
+RNC1: Terminadores requeridos
+      Base: Organización de código, trazabilidad
+      Operadores: {SHA, OZ, NAV, REMESH}
+```
+
+---
+
+## Comparación: Estado Actual vs Estado Canónico
+
+### Estado Actual (EXECUTIVE_SUMMARY.md)
+
+```
+Reglas Canónicas: RC1, RC2
+Composición: 66% física + 33% convención
+```
+
+### Estado Canónico Propuesto
+
+```
+Reglas Canónicas: RC1, RC2, RC3, RC4 (condicional)
+Composición: 80% física + 20% convención
+```
+
+**Cambios requeridos:**
+
+1. **Añadir RC3 (Verificación de Fase)**
+   - Hacer `UM_STRICT_PHASE_CHECK=True` por defecto
+   - Añadir a `canonical_grammar.py`
+   - Validar en secuencias con UM/RA
+
+2. **Documentar RC4 (Límite de Bifurcación)**
+   - Reconocer como regla emergente condicional
+   - Mantener validación en preconditions
+   - Opcional: elevar a grammar como RC4
+
+3. **Actualizar EXECUTIVE_SUMMARY.md**
+   - Reflejar RC3 como regla canónica
+   - Mencionar RC4 como regla emergente condicional
+   - Actualizar porcentajes (80% física / 20% convención)
+
+---
+
+## Conclusión
+
+### Hallazgos Clave
+
+1. **✅ RC1 y RC2**: Correctamente identificadas y implementadas
+2. **🆕 RC3 (Verificación de Fase)**: **FALTANTE** - Identificada en invariantes pero no en gramática
+3. **🆕 RC4 (Límite de Bifurcación)**: Implementada en preconditions pero no reconocida como regla gramatical
+4. **⚠️ RNC1 (Terminadores)**: Correctamente identificada como convencional
+
+### Recomendaciones
+
+**Para gramática canónica:**
+1. **Implementar RC3** como regla obligatoria (no opcional)
+2. **Considerar RC4** como regla condicional (aplica si bifurcación activa)
+3. **Mantener RNC1** como convención útil pero documentada como no-física
+
+**Para EXECUTIVE_SUMMARY.md:**
+1. Actualizar con RC3 como regla canónica
+2. Mencionar RC4 como propiedad emergente
+3. Actualizar composición: **75-80% física / 20-25% convención**
+
+### Impacto en TNFR
+
+**Solidez teórica:** ✅ **MEJORADA**
+- Identificación de RC3 refuerza consistencia con Invariante #5
+- Reconocimiento de RC4 conecta gramática con física de bifurcaciones
+- Porcentaje de física canónica aumenta de 66% a 75-80%
+
+**Implementación:** ⚠️ **REQUIERE AJUSTES**
+- RC3: Cambiar `UM_STRICT_PHASE_CHECK` a obligatorio
+- RC4: Ya implementado, solo requiere reconocimiento formal
+- Tests: Añadir validación de RC3 en `test_canonical_grammar.py`
+
+---
+
+## Próximos Pasos
+
+1. [ ] Actualizar `canonical_grammar.py` con RC3
+2. [ ] Cambiar `UM_STRICT_PHASE_CHECK=True` por defecto
+3. [ ] Añadir tests para RC3
+4. [ ] Documentar RC4 como regla condicional
+5. [ ] Actualizar EXECUTIVE_SUMMARY.md
+6. [ ] Verificar que todos los invariantes tengan reglas gramaticales correspondientes
+
+**Estado final esperado:**
+```
+Gramática TNFR 2.0:
+- RC1: Generadores ✅
+- RC2: Estabilizadores ✅  
+- RC3: Verificación de Fase 🆕
+- RC4: Límite de Bifurcación 🆕 (condicional)
+- RNC1: Terminadores ⚠️ (convención)
+
+Composición: 75-80% física pura
+```