# **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
