MODELO BASICO DE PODER

 # **Notebook Python: Simulación de Dinámicas de Poder (Poderosos vs. Invisibles)**

```python
# -*- coding: utf-8 -*-
"""
Simulación de Teoría del Poder - José Agustín Fontán Varela (09/04/2025)
Análisis de dinámicas de poder usando índices de transparencia gubernamental
"""

import numpy as np
import matplotlib.pyplot as plt
from ipywidgets import interact, FloatSlider
import pandas as pd

# --------------------------------------------
# 1. MODELO BÁSICO DE PODER (MBP)
# --------------------------------------------
def modelo_poder(t, P, I, alpha=0.1, beta=0.05, gamma=0.03, delta=0.01, K=1.0, lambd=2.0):
    """
    Resuelve el sistema de ecuaciones diferenciales del poder:
    dP/dt = αP(1 - P/K) - βI·exp(-λσ(P))
    dI/dt = γI·exp(-λσ(P)) - δPI
    
    Parámetros:
    alpha: Tasa de crecimiento del poder
    beta: Efecto de resistencia de los invisibles
    gamma: Tasa de organización de los invisibles
    delta: Efecto represivo del poder
    K: Capacidad de carga del sistema
    lambd: Factor de sensibilidad al secretismo
    """
    sigma = 0.8  # Índice de secretismo (0-1)
    confianza = np.exp(-lambd * sigma)
    
    dPdt = alpha * P * (1 - P/K) - beta * I * confianza
    dIdt = gamma * I * confianza - delta * P * I
    
    return dPdt, dIdt

# --------------------------------------------
# 2. SIMULACIÓN CON DATOS REALES
# --------------------------------------------
# Cargar datos de transparencia (ejemplo)
def cargar_datos():
    """Datos ficticios basados en el Índice de Percepción de la Corrupción"""
    años = np.arange(2010, 2023)
    paises = ['País A', 'País B', 'País C']
    transparencia = {
        'País A': np.clip(np.random.normal(0.6, 0.1, len(años)), 0, 1),
        'País B': np.clip(np.random.normal(0.4, 0.15, len(años)), 0, 1),
        'País C': np.clip(np.random.normal(0.3, 0.2, len(años)), 0, 1)
    }
    return pd.DataFrame(transparencia, index=años)

# --------------------------------------------
# 3. VISUALIZACIÓN INTERACTIVA
# --------------------------------------------
def simulador_interactivo(alpha=0.1, beta=0.05, gamma=0.03, delta=0.01, lambd=2.0):
    t = np.linspace(0, 50, 500)
    P0, I0 = 0.1, 0.9  # Valores iniciales
    
    # Resolver numéricamente
    P, I = np.zeros_like(t)), np.zeros_like(t))
    P[0], I[0] = P0, I0
    
    for i in range(1, len(t)):
        dt = t[i] - t[i-1]
        dP, dI = modelo_poder(t[i-1], P[i-1], I[i-1], alpha, beta, gamma, delta, 1.0, lambd)
        P[i] = P[i-1] + dP * dt
        I[i] = I[i-1] + dI * dt
    
    # Visualización
    plt.figure(figsize=(12, 6))
    plt.plot(t, P, 'r-', label='Poderosos (P)')
    plt.plot(t, I, 'b--', label='Invisibles (I)')
    plt.title('Dinámica de Poder: Poderosos vs Invisibles\n' +
              r'$\alpha={}$, $\beta={}$, $\gamma={}$, $\lambda={}$'.format(alpha, beta, gamma, lambd))
    plt.xlabel('Tiempo')
    plt.ylabel('Poder Relativo')
    plt.legend()
    plt.grid(True)
    plt.ylim(0, 1.2)
    
    # Añadir región crítica
    plt.fill_between(t, 0, 1, where=(I > P),
                    color='blue', alpha=0.1, label='Zona de Contrapoder')
    plt.axhline(1, color='k', linestyle=':', alpha=0.5)
    plt.text(t[-1]+1, 1.02, 'Límite de capacidad del sistema', ha='right')
    
    plt.show()

# --------------------------------------------
# 4. ANÁLISIS POR PAÍSES
# --------------------------------------------
def analisis_paises():
    datos = cargar_datos()
    fig, ax = plt.subplots(1, 2, figsize=(15, 5))
    
    # Gráfico de transparencia
    datos.plot(ax=ax[0], marker='o')
    ax[0].set_title('Índice de Transparencia Gubernamental')
    ax[0].set_ylabel('Transparencia (0-1)')
    ax[0].set_ylim(0, 1)
    
    # Simulación por país
    for pais in datos.columns:
        sigma = 1 - datos[pais].mean()  # Secretismo = 1 - Transparencia
        t = np.arange(len(datos))
        P = np.zeros_like(t, dtype=float))
        I = np.zeros_like(t, dtype=float))
        P[0], I[0] = 0.2, 0.8
        
        for i in range(1, len(t)):
            confianza = np.exp(-2 * sigma)
            dP = 0.1*P[i-1]*(1-P[i-1]) - 0.05*I[i-1]*confianza
            dI = 0.03*I[i-1]*confianza - 0.01*P[i-1]*I[i-1]
            P[i] = P[i-1] + dP
            I[i] = I[i-1] + dI
        
        ax[1].plot(t, P, '--', label=f'{pais} - Poder')
        ax[1].plot(t, I, '-', label=f'{pais} - Invisibles')
    
    ax[1].set_title('Dinámica de Poder por País')
    ax[1].set_xlabel('Años desde 2010')
    ax[1].legend()
    plt.tight_layout()
    plt.show()

# --------------------------------------------
# INTERFAZ INTERACTIVA
# --------------------------------------------
print("""
SIMULADOR DE DINÁMICAS DE PODER
--------------------------------
Teoría de José Agustín Fontán Varela (2025)
""")

# Widgets interactivos
interact(simulador_interactivo,
         alpha=FloatSlider(min=0.01, max=0.5, step=0.01, value=0.1),
         beta=FloatSlider(min=0.01, max=0.2, step=0.01, value=0.05),
         gamma=FloatSlider(min=0.01, max=0.2, step=0.01, value=0.03),
         delta=FloatSlider(min=0.001, max=0.1, step=0.001, value=0.01),
         lambd=FloatSlider(min=0.5, max=5, step=0.1, value=2.0))

# Análisis comparativo
print("\n\nANÁLISIS COMPARATIVO POR PAÍSES (DATOS FICTICIOS)")
analisis_paises()
```

## **Instrucciones de Uso:**

1. **Requisitos:**
   ```bash
   pip install numpy matplotlib pandas ipywidgets
   jupyter nbextension enable --py widgetsnbextension
   ```

2. **Ejecución:**
   - Guardar como `teoria_poder_simulacion.ipynb`
   - Abrir con Jupyter Notebook/Lab

3. **Funcionalidades:**
   - **Simulador interactivo**: Ajustar parámetros en tiempo real
   - **Análisis por países**: Comparativa con datos de transparencia
   - **Visualización**:
     - Líneas rojas/azules = Evolución de poder
     - Área azul = Zonas donde los invisibles superan a los poderosos

## **Interpretación de Resultados:**

1. **Puntos de inflexión**: Cuando las curvas se cruzan indica cambios de régimen
2. **Efecto transparencia**: Países con menor `sigma` (más transparentes) muestran menor brecha P/I
3. **Límite del sistema**: Ningún grupo puede superar 1 (capacidad máxima del sistema)

**Nota**: Los datos usados son ilustrativos. Para investigación real, cargar CSV con:
```python
datos_reales = pd.read_csv('indices_transparencia.csv', index_col=0)
```

Tormenta Work Free Intelligence + IA Free Intelligence Laboratory by José Agustín Fontán Varela is licensed under CC BY-NC-ND 4.0