Merge pull request #2822 from fermga/copilot/validate-canonical-properties-sha

[SHA Algebra] Complete canonical grammar derivation from TNFR physics

Author: fermga

CANONICAL_GRAMMAR_DERIVATION.md

@@ -0,0 +1,392 @@
+# Derivación Canónica de la Gramática TNFR desde Primeros Principios
+
+## Objetivo
+
+Derivar una gramática de operadores que emerja **exclusivamente** de la ecuación nodal y sus consecuencias matemáticas inevitables, eliminando toda convención organizativa.
+
+---
+
+## Axioma Fundamental
+
+```
+∂EPI/∂t = νf · ΔNFR(t)
+```
+
+Esta es la **única fuente de verdad**. Todo lo demás debe derivarse de aquí.
+
+---
+
+## Derivación Matemática de Restricciones
+
+### Restricción 1: Condiciones de Inicialización (R1 - GENERADORES)
+
+**Problema matemático:**
+```
+Si EPI₀ = 0 (nodo vacío)
+Entonces ∂EPI/∂t|_{EPI=0} es indefinido o cero
+```
+
+**Análisis:**
+- La derivada parcial requiere una estructura sobre la cual actuar
+- En un espacio discreto de configuraciones, EPI=0 no tiene vecindad definida
+- Sin estructura inicial, no hay gradiente ΔNFR definible
+
+**Consecuencia inevitable:**
+```
+∃ operadores G ⊂ Operadores tal que:
+∀ g ∈ G: g(EPI=0) → EPI>0 (generación de estructura)
+```
+
+**Necesidad física:** ✅ **ABSOLUTA**
+- Matemática: Derivada indefinida en origen
+- Física: No puedes evolucionar lo que no existe
+
+**Operadores canónicos:**
+- **AL (Emission)**: Genera EPI desde potencial cuántico
+- **NAV (Transition)**: Activa EPI latente existente
+- **REMESH (Recursivity)**: Replica/transforma estructura existente
+
+**Regla derivada:**
+```
+R1_CANONICAL: Toda secuencia operacional debe comenzar con g ∈ {AL, NAV, REMESH}
+              o actuar sobre nodo ya inicializado (EPI > 0)
+```
+
+---
+
+### Restricción 2: Condiciones de Convergencia (R2 - ESTABILIZADORES)
+
+**Problema matemático:**
+```
+Integral de la ecuación nodal:
+EPI(t_f) = EPI(t_0) + ∫_{t_0}^{t_f} νf(τ) · ΔNFR(τ) dτ
+```
+
+**Análisis de divergencia:**
+
+Sin retroalimentación negativa:
+```
+ΔNFR(t) puede crecer sin límite
+Si ΔNFR'(t) > 0 siempre (feedback positivo puro)
+Entonces ΔNFR(t) ~ e^(λt) para algún λ > 0
+```
+
+**Consecuencia:**
+```
+∫_{t_0}^{∞} νf(τ) · ΔNFR(τ) dτ → ∞ (diverge)
+```
+
+**Teorema de convergencia:**
+Para que la integral converja, debe existir retroalimentación negativa:
+```
+∃ s ∈ S ⊂ Operadores tal que:
+s reduce |ΔNFR| o crea límites autopoiéticos
+```
+
+**Necesidad física:** ✅ **ABSOLUTA**
+- Matemática: Teorema de convergencia de integrales
+- Física: Sin límites, el sistema se fragmenta en ruido incoherente
+
+**Operadores canónicos:**
+- **IL (Coherence)**: Retroalimentación negativa explícita (reduce |ΔNFR|)
+- **THOL (Self-organization)**: Crea límites autopoiéticos (acotan evolución)
+
+**Regla derivada:**
+```
+R2_CANONICAL: Toda secuencia con duración t > τ_critical debe incluir
+              s ∈ {IL, THOL} para garantizar ∫νf·ΔNFR dt < ∞
+```
+
+---
+
+### Restricción 3: ¿Terminadores Obligatorios? (R3 - ANÁLISIS CRÍTICO)
+
+**Pregunta:** ¿La ecuación nodal requiere que secuencias "terminen" de forma específica?
+
+**Análisis matemático:**
+
+La ecuación nodal en tiempo continuo:
+```
+∂EPI/∂t = νf · ΔNFR(t)
+```
+
+No contiene información sobre "terminación de secuencias". Solo describe evolución local.
+
+**Argumentos a favor de terminadores:**
+1. ❌ "Evita estados indefinidos" → No física; cualquier estado con EPI, νf, ΔNFR definidos es válido
+2. ❌ "Necesario para cerrar ciclos" → Convención de software, no requisito matemático
+3. ❌ "Garantiza trazabilidad" → Convención organizativa
+
+**Argumentos en contra:**
+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
+
+**Conclusión:**
+```
+R3 NO es canónica. Es una convención útil pero NO emerge de ∂EPI/∂t = νf · ΔNFR(t)
+```
+
+**Necesidad física:** ❌ **CONVENCIONAL**
+- No hay base matemática en la ecuación nodal
+- Útil para organización pero no físicamente necesaria
+
+---
+
+## Gramática Canónica Mínima (100% Física)
+
+### Reglas Canónicas (Derivadas Inevitablemente)
+
+**RC1: Inicialización**
+```
+Si EPI₀ = 0:
+    Primer operador ∈ {AL, NAV, REMESH}
+```
+**Fundamento:** ∂EPI/∂t indefinido en EPI=0
+
+**RC2: Convergencia**
+```
+Si secuencia incluye operadores que aumentan |ΔNFR|:
+    Debe incluir IL o THOL antes de t_max
+```
+**Fundamento:** ∫νf·ΔNFR dt debe converger
+
+### Reglas NO Canónicas (Convencionales)
+
+**RNC1: Terminadores obligatorios**
+```
+Secuencia debe terminar con {SHA, OZ, NAV, REMESH}
+```
+**Fundamento:** Ninguno físico. Útil para organización.
+
+**RNC2: Restricciones de composición específicas**
+```
+Ejemplo: "SHA no puede seguir a X"
+```
+**Fundamento:** Semántica de alto nivel, no ecuación nodal.
+
+---
+
+## Análisis de Operadores Individuales desde Física
+
+### SHA (Silence)
+
+**Efecto en ecuación nodal:**
+```
+SHA: νf → ε (donde ε ≈ 0)
+∴ ∂EPI/∂t = ε · ΔNFR(t) ≈ 0
+```
+
+**Propiedades que emergen:**
+1. **Identidad estructural**: EPI no evoluciona → SHA(g(ω)) ≈ g(ω)
+2. **Idempotencia**: νf ya en mínimo → SHA^n = SHA
+3. **Conmutatividad con NUL**: νf ⊥ dim(EPI) → SHA ∘ NUL = NUL ∘ SHA
+
+**¿SHA es "terminador" canónico?**
+```
+NO. SHA es un estado válido, pero NO hay requisito físico de que sea terminal.
+Un nodo puede estar en SHA y posteriormente ser reactivado con AL/NAV.
+```
+
+### NUL (Contraction)
+
+**Efecto en ecuación nodal:**
+```
+NUL: Reduce dim(EPI) (complejidad estructural)
+```
+
+**¿NUL es "terminador"?**
+```
+NO desde física pura. Un nodo contraído puede evolucionar posteriormente.
+La restricción de que NUL no sea terminador es CONVENCIONAL.
+```
+
+---
+
+## Propuesta: Gramática Puramente Canónica
+
+### Nivel 1: Restricciones Físicas Absolutas
+
+```python
+class CanonicalGrammar:
+    """Gramática derivada exclusivamente de ∂EPI/∂t = νf · ΔNFR(t)"""
+    
+    @staticmethod
+    def validate_initialization(sequence: List[Operator], epi_initial: float) -> bool:
+        """RC1: Verifica inicialización si EPI=0"""
+        if epi_initial == 0.0:
+            if not sequence:
+                return False
+            first_op = sequence[0].canonical_name
+            return first_op in {'emission', 'transition', 'recursivity'}
+        return True  # Si EPI>0, no se requiere generador
+    
+    @staticmethod
+    def validate_convergence(sequence: List[Operator]) -> bool:
+        """RC2: Verifica que secuencia no diverge"""
+        has_destabilizer = any(
+            op.canonical_name in {'dissonance', 'mutation', 'expansion'}
+            for op in sequence
+        )
+        if not has_destabilizer:
+            return True  # Sin desestabilizadores, no hay riesgo de divergencia
+        
+        has_stabilizer = any(
+            op.canonical_name in {'coherence', 'self_organization'}
+            for op in sequence
+        )
+        return has_stabilizer
+    
+    @staticmethod
+    def is_canonical(sequence: List[Operator], epi_initial: float) -> bool:
+        """Valida solo restricciones canónicas (RC1, RC2)"""
+        return (
+            CanonicalGrammar.validate_initialization(sequence, epi_initial) and
+            CanonicalGrammar.validate_convergence(sequence)
+        )
+```
+
+### Nivel 2: Convenciones Organizativas (Opcionales)
+
+```python
+class ConventionalGrammar(CanonicalGrammar):
+    """Añade convenciones útiles pero no canónicas"""
+    
+    @staticmethod
+    def validate_termination(sequence: List[Operator]) -> bool:
+        """RNC1: Convención de terminadores (NO canónica)"""
+        if not sequence:
+            return False
+        last_op = sequence[-1].canonical_name
+        return last_op in {'silence', 'dissonance', 'transition', 'recursivity'}
+    
+    @staticmethod
+    def is_valid(sequence: List[Operator], epi_initial: float) -> bool:
+        """Valida canónico + convencional"""
+        return (
+            CanonicalGrammar.is_canonical(sequence, epi_initial) and
+            ConventionalGrammar.validate_termination(sequence)
+        )
+```
+
+---
+
+## Comparación: Gramática Actual vs Canónica
+
+### Gramática Actual (Implementación)
+
+```
+C1: Debe empezar con {AL, NAV, REMESH}
+C2: Debe incluir {IL, THOL}
+C3: Debe terminar con {SHA, OZ, NAV, REMESH}
+```
+
+**Análisis:**
+- C1: ✅ Canónica (RC1)
+- C2: ✅ Canónica (RC2)
+- C3: ❌ NO canónica (convención)
+
+**Veredicto:** 66% canónica, 33% convencional
+
+### Gramática Canónica Propuesta
+
+```
+RC1: Si EPI=0, empezar con {AL, NAV, REMESH}
+RC2: Si hay desestabilizadores, incluir {IL, THOL}
+```
+
+**Análisis:**
+- RC1: ✅ Derivada de ∂EPI/∂t indefinido en 0
+- RC2: ✅ Derivada de teorema de convergencia
+
+**Veredicto:** 100% canónica
+
+---
+
+## Implicaciones para Tests Algebraicos
+
+### Enfoque Actual (Respetando Convenciones)
+
+```python
+# Test que respeta C1, C2, C3
+def test_sha_identity():
+    G, node = create_nfr("test", epi=0.5)
+    # Usa: AL → IL → SHA (válido bajo C1, C2, C3)
+    validate_identity_property(G, node, Emission())
+```
+
+**Problema:** Tests limitados por C3 (no canónica)
+
+### Enfoque Canónico (Solo RC1, RC2)
+
+```python
+# Test que respeta solo RC1, RC2
+def test_sha_identity_canonical():
+    G, node = create_nfr("test", epi=0.5)
+    # Usa: AL → IL (válido bajo RC1, RC2)
+    # No necesita terminador obligatorio
+    validate_identity_property_canonical(G, node, Emission())
+```
+
+**Ventaja:** Tests más directos de propiedades físicas
+
+---
+
+## Recomendaciones
+
+### Para Implementación de Producción
+
+**Mantener gramática actual (C1+C2+C3):**
+- C1, C2: Canónicas (física)
+- C3: Convencional pero útil (trazabilidad, organización)
+
+**Documentar claramente:**
+```python
+# C1, C2: Restricciones físicas inevitables (OBLIGATORIO)
+# C3: Convención organizativa (RECOMENDADO pero no físico)
+```
+
+### Para Validación de Propiedades Algebraicas
+
+**Opción A: Modo de test canónico**
+Permitir bypass de C3 en contexto de testing cuando validas física pura:
+```python
+@pytest.mark.canonical_only
+def test_sha_properties():
+    # Ignora C3, respeta solo RC1, RC2
+    pass
+```
+
+**Opción B: Adaptar tests a convenciones**
+Mantener como está, documentando que tests respetan convenciones además de física.
+
+---
+
+## Conclusión
+
+### Gramática 100% Canónica (Solo Física)
+
+```
+RC1: Inicialización - Si EPI=0, usar generador
+RC2: Convergencia - Si desestabilizadores, usar estabilizador
+```
+
+**Fundamento:** Derivadas inevitables de ∂EPI/∂t = νf · ΔNFR(t)
+
+### Gramática Actual (Física + Convención)
+
+```
+C1: RC1 (canónica)
+C2: RC2 (canónica)
+C3: Terminadores (convencional)
+```
+
+**Composición:** 66% física, 33% convención
+
+### Propuesta para Este PR
+
+1. **Documentar claramente** en código qué reglas son físicas vs convencionales
+2. **Considerar** modo de testing que respeta solo RC1, RC2
+3. **Tests actuales** son pragmáticos (respetan convenciones) pero **documentan** que validan física
+
+**La gramática actual es razonable para producción.** Lo importante es **documentar** qué emerge de física vs qué es convención organizativa.