"[0, 1] — Probabilístico": {

"min": 0.0, "max": 1.0, "neutro": 0.5,

"descripcion": "Opinión como probabilidad de apoyo. Neutro=0.5. Modelos SIR, adopción.",

"ejemplo_apoyo": 0.8, "ejemplo_rechazo": 0.2, "ejemplo_neutro": 0.5,

"defaults": {

"opinion_inicial": 0.50, "propaganda": 0.70, "confianza": 0.40,

"opinion_grupo_a": 0.72, "opinion_grupo_b": 0.28,

},

},

"[-1, 1] — Bipolar": {

"min": -1.0, "max": 1.0, "neutro": 0.0,

"descripcion": "Rechazo activo en negativo. Neutro=0. Polarización, campañas, elecciones.",

"ejemplo_apoyo": 0.7, "ejemplo_rechazo": -0.7, "ejemplo_neutro": 0.0,

"defaults": {

"opinion_inicial": 0.00, "propaganda": 0.40, "confianza": 0.40,

"opinion_grupo_a": 0.65, "opinion_grupo_b": -0.55,

},

},

"heurístico": {

"descripcion": "Sin LLM — lógica determinista, sin costo ni API key",

"requiere_key": False, "base_url": None,

"modelos_sugeridos": ["(ninguno)"],

},

"ollama": {

"descripcion": "LLM local con Ollama — privado, sin costo por llamada",

"requiere_key": False, "base_url": "http://localhost:11434",

"modelos_sugeridos": ["llama3:8b", "mistral:7b", "phi3:mini", "gemma2:2b"],

},

"groq": {

"descripcion": "Groq Cloud — muy rápido, tier gratuito generoso",

"requiere_key": True, "base_url": "https://api.groq.com/openai/v1",

"modelos_sugeridos": [

"llama-3.1-8b-instant", "llama-3.3-70b-versatile",

"meta-llama/llama-4-scout-17b-16e-instruct",

],

},

"openai": {

"descripcion": "OpenAI API — GPT-4o, GPT-4o-mini, etc.",

"requiere_key": True, "base_url": "https://api.openai.com/v1",

"modelos_sugeridos": ["gpt-4o-mini", "gpt-4o", "gpt-4.1-nano"],

},

"openrouter": {

"descripcion": "OpenRouter — acceso a cientos de modelos con una sola key",

"requiere_key": True, "base_url": "https://openrouter.ai/api/v1",

"modelos_sugeridos": [

"meta-llama/llama-3.3-70b-instruct",

"google/gemini-flash-1.5",

"mistralai/mistral-7b-instruct",

],

},

# Rango

"rango": "[0, 1] — Probabilístico",

# LLM

"proveedor": "heurístico",

"modelo": "",

"api_key": "",

"ollama_host": "http://localhost:11434",

"llm_timeout": 20,

"llm_temperature": 0.0,

# Motor

"alpha_blend": 0.8,

"ruido_base": 0.03,

"ruido_desconfianza": 0.08,

"efecto_vecinos_peso": 0.05,

"ventana_historial_llm": 6,

# Simulación múltiple

"ruido_estado_inicial": 0.01,

# ── Nuevos mecanismos ──────────────────────────────────

# Sesgo de confirmación: propaganda contraria pierde peso

# 0.0 = sin sesgo | 1.0 = sesgo total (ignora información contraria)

"sesgo_confirmacion": 0.3,

# HK — Confianza Acotada

# Solo se escucha a quienes están a ≤ epsilon de distancia

"hk_epsilon": 0.3,

# Contagio Competitivo

# Peso de la narrativa B al competir con la A

"competencia_peso": 0.4,

# Umbral Heterogéneo (Granovetter)

# Media y std de la distribución de umbrales individuales

"umbral_media": 0.5,

"umbral_std": 0.15,

# Homofilia dinámica

# Velocidad con la que los pesos de grupo se actualizan según similitud de opinión

"homofilia_tasa": 0.05,

"lineal": {"a": (0.5, 0.9), "b": (0.1, 0.5)},

"umbral": {"umbral": (0.3, 0.8), "incremento": (0.05, 0.3)},

"memoria": {"alpha": (0.5, 0.8), "beta": (0.1, 0.3), "gamma": (0.05, 0.2)},

"backlash": {"penalizacion": (0.05, 0.3)},

"polarizacion": {"fuerza": (0.05, 0.25)},

"hk": {"epsilon": (0.1, 0.6)},

"contagio_competitivo": {"competencia": (0.2, 0.7)},

"umbral_heterogeneo": {"media": (0.3, 0.7), "std": (0.05, 0.25)},

"homofilia": {"tasa": (0.02, 0.15)},

"replicador": {"dt": (0.01, 1.0)},

cfg: dict) -> float:

"""

sesgo = float(np.clip(cfg.get("sesgo_confirmacion", 0.0), 0.0, 1.0))

neutro = _neutro(cfg)

if sesgo == 0.0:

return propaganda

# Detect if they are in opposite directions from neutral

misma_dir = (opinion - neutro) * (propaganda - neutro) >= 0

if misma_dir:

return propaganda

else:

# Attenuation proportional to bias

"""

tasa = float(np.clip(cfg.get("homofilia_tasa", 0.05), 0.0, 0.3))

opinion = estado["opinion"]

op_a = estado.get("opinion_grupo_a", 0.7)

op_b = estado.get("opinion_grupo_b", 0.3)

perten = estado.get("pertenencia_grupo", 0.6)

# Similarity = 1 - normalized distance to range

amp = _amplitud(cfg)

sim_a = 1.0 - abs(opinion - op_a) / amp

sim_b = 1.0 - abs(opinion - op_b) / amp

# Update belonging towards the most similar group

nuevo_perten = perten + tasa * (sim_a - sim_b)

nuevo_perten = float(np.clip(nuevo_perten, 0.1, 0.9))

"""

a, b = params.get("a", 0.7), params.get("b", 0.3)

prop = _aplicar_sesgo_confirmacion(estado["propaganda"], estado["opinion"], cfg)

nuevo = estado.copy()

nuevo["opinion"] = _clip(a * estado["opinion"] + b * prop, cfg)

"""

r = _get_rango(cfg)

umbral = params.get("umbral", 0.65 if not _es_bipolar(cfg) else 0.4)

incremento = params.get("incremento", 0.15)

prop = _aplicar_sesgo_confirmacion(estado["propaganda"], estado["opinion"], cfg)

nuevo = estado.copy()

if abs(prop) > abs(umbral):

signo = np.sign(prop) if _es_bipolar(cfg) else 1.0

val = estado["opinion"] + signo * incremento * (r["max"] - abs(estado["opinion"]))

else:

val = estado["opinion"]

nuevo["opinion"] = _clip(val, cfg)

"""

alpha = params.get("alpha", 0.7)

beta = params.get("beta", 0.2)

gamma = params.get("gamma", 0.1)

prev = estado.get("opinion_prev", estado["opinion"])

prop = _aplicar_sesgo_confirmacion(estado["propaganda"], estado["opinion"], cfg)

nuevo = estado.copy()

nuevo["opinion"] = _clip(

alpha * estado["opinion"] + beta * prev + gamma * prop, cfg

)

"""

penalizacion = params.get("penalizacion", 0.15)

prop = _aplicar_sesgo_confirmacion(estado["propaganda"], estado["opinion"], cfg)

nuevo = estado.copy()

neutro = _neutro(cfg)

if _es_bipolar(cfg):

if estado["opinion"] < neutro:

val = estado["opinion"] - penalizacion * abs(prop)

else:

val = estado["opinion"]

else:

umbral_inf = params.get("umbral_inferior", 0.35)

if estado["opinion"] < umbral_inf:

val = estado["opinion"] - penalizacion * prop

else:

val = estado["opinion"]

nuevo["opinion"] = _clip(val, cfg)

"""

fuerza = params.get("fuerza", 0.1)

opinion = estado["opinion"]

neutro = _neutro(cfg)

r = _get_rango(cfg)

nuevo = estado.copy()

if opinion >= neutro:

val = opinion + fuerza * (r["max"] - opinion)

else:

val = opinion - fuerza * (opinion - r["min"])

nuevo["opinion"] = _clip(val, cfg)

"""

epsilon = params.get("epsilon", cfg.get("hk_epsilon", 0.3))

opinion = estado["opinion"]

op_a = estado.get("opinion_grupo_a", _get_rango(cfg)["ejemplo_apoyo"])

op_b = estado.get("opinion_grupo_b", _get_rango(cfg)["ejemplo_rechazo"])

perten = estado.get("pertenencia_grupo", 0.6)

prop = _aplicar_sesgo_confirmacion(estado["propaganda"], opinion, cfg)

# Determinar qué grupos están dentro del radio de confianza

grupos_validos = []

pesos_validos = []

if abs(opinion - op_a) <= epsilon:

grupos_validos.append(op_a)

pesos_validos.append(perten)

if abs(opinion - op_b) <= epsilon:

grupos_validos.append(op_b)

pesos_validos.append(1.0 - perten)

nuevo = estado.copy()

if grupos_validos:

# Promedio ponderado solo de grupos dentro del radio

total_peso = sum(pesos_validos)

opinion_ref = sum(g * p for g, p in zip(grupos_validos, pesos_validos)) / total_peso

# Convergencia gradual hacia la referencia de confianza

alpha = params.get("alpha", 0.3)

val = opinion + alpha * (opinion_ref - opinion) + 0.05 * prop

else:

# Nadie dentro del radio → fragmentación, opinión casi estática

val = opinion + 0.01 * prop # influencia mínima de propaganda

nuevo["opinion"] = _clip(val, cfg)

"""

competencia = params.get("competencia", cfg.get("competencia_peso", 0.4))

opinion = estado["opinion"]

narrativa_a = _aplicar_sesgo_confirmacion(estado["propaganda"], opinion, cfg)

# narrativa_b puede estar en el estado o inferirse como la opuesta

narrativa_b = estado.get("narrativa_b", -narrativa_a if _es_bipolar(cfg) else 1.0 - narrativa_a)

# Influencia neta: A gana si es más fuerte que B

influencia_neta = narrativa_a - competencia * narrativa_b

neutro = _neutro(cfg)

# La influencia neta empuja la opinión hacia o desde el neutro

nuevo = estado.copy()

val = opinion + 0.15 * influencia_neta * (1.0 - abs(opinion - neutro) / _amplitud(cfg))

nuevo["opinion"] = _clip(val, cfg)

"""

media = params.get("media", cfg.get("umbral_media", 0.5))

std = params.get("std", cfg.get("umbral_std", 0.15))

opinion = estado["opinion"]

neutro = _neutro(cfg)

prop = _aplicar_sesgo_confirmacion(estado["propaganda"], opinion, cfg)

# Fracción de la población que ya superó su umbral personal

# (modelado con CDF de la normal)

fraccion_adoptantes = 0.5 * (1 + erf((opinion - neutro - media + 0.5) / (std * np.sqrt(2))))

fraccion_adoptantes = float(np.clip(fraccion_adoptantes, 0.0, 1.0))

# La fracción de adoptantes genera presión social adicional

r = _get_rango(cfg)

val = opinion + 0.2 * fraccion_adoptantes * (r["max"] - opinion) + 0.05 * prop

nuevo = estado.copy()

nuevo["opinion"] = _clip(val, cfg)

# Guardar fracción para análisis

nuevo["_fraccion_adoptantes"] = round(fraccion_adoptantes, 3)

"""

tasa = params.get("tasa", cfg.get("homofilia_tasa", 0.05))

opinion = estado["opinion"]

op_a = estado.get("opinion_grupo_a", _get_rango(cfg)["ejemplo_apoyo"])

op_b = estado.get("opinion_grupo_b", _get_rango(cfg)["ejemplo_rechazo"])

perten = estado.get("pertenencia_grupo", 0.6)

prop = _aplicar_sesgo_confirmacion(estado["propaganda"], opinion, cfg)

amp = _amplitud(cfg)

# Similitud normalizada al rango

sim_a = 1.0 - abs(opinion - op_a) / amp

sim_b = 1.0 - abs(opinion - op_b) / amp

# Actualizar pertenencia según similitud (homofilia)

nuevo_perten = float(np.clip(perten + tasa * (sim_a - sim_b), 0.1, 0.9))

# Calcular referencia social con nuevos pesos

ref_social = nuevo_perten * op_a + (1.0 - nuevo_perten) * op_b

peso_social = cfg.get("efecto_vecinos_peso", 0.05)

val = opinion + peso_social * (ref_social - opinion) + 0.08 * prop

nuevo = estado.copy()

nuevo["opinion"] = _clip(val, cfg)

nuevo["pertenencia_grupo"] = nuevo_perten # persiste al próximo paso

nuevo["_sim_grupo_a"] = round(sim_a, 3)

nuevo["_sim_grupo_b"] = round(sim_b, 3)

"""

data_array = np.array(window_data, dtype=float)

if data_array.ndim == 1:

data_array = data_array.reshape(-1, 1) # shape: (T, n_vars)

variance = np.var(data_array, axis=0)

n_vars = data_array.shape[1]

autocorr = np.zeros(n_vars)

for i in range(n_vars):

if data_array.shape[0] > 1:

cc = np.corrcoef(data_array[:-1, i], data_array[1:, i])

val = cc[0, 1]

autocorr[i] = val if not np.isnan(val) else 0.0

skewness = stats.skew(data_array, axis=0)

"""

return {

"high_variance": bool(

np.mean(metrics["variance"]) > thresholds.get("mean_variance_threshold", 0.1)

),

"high_autocorr": bool(

np.mean(metrics["autocorr"]) > thresholds.get("mean_autocorr_threshold", 0.5)

),

"high_skewness": bool(

np.mean(np.abs(metrics["skewness"])) > thresholds.get("mean_skewness_threshold", 0.5)

),

population_states: np.ndarray,

payoff_matrix: np.ndarray,

dt: float,

) -> np.ndarray:

"""

pop = np.array(population_states, dtype=float)

total = np.sum(pop)

if total == 0.0:

return pop

pop = pop / total

def replicator_rhs(t: float, x: np.ndarray) -> np.ndarray:

x = np.clip(x, 0.0, 1.0)

s = np.sum(x)

if s > 0.0:

x = x / s

f = payoff_matrix @ x

f_avg = x @ f

return x * (f - f_avg)

sol = solve_ivp(replicator_rhs, [0.0, dt], pop, method="RK45", dense_output=False)

new_pop = sol.y[:, -1]

new_pop = np.clip(new_pop, 0.0, 1.0)

total_new = np.sum(new_pop)

"""

pertenencia = estado.get("pertenencia_grupo", 0.6)

pop = np.array([pertenencia, 1.0 - pertenencia], dtype=float)

raw_payoff = params.get(

"payoff_matrix",

cfg.get("payoff_matrix", DEFAULT_PAYOFF_MATRIX),

)

payoff_matrix = np.array(raw_payoff, dtype=float)

if payoff_matrix.shape != (2, 2):

payoff_matrix = np.eye(2)

dt = float(params.get("dt", cfg.get("dt", 0.1)))

updated = apply_replicator_equation(pop, payoff_matrix, dt)

nuevo_perten = float(np.clip(updated[0], 0.1, 0.9))

op_a = estado.get("opinion_grupo_a", _get_rango(cfg)["ejemplo_apoyo"])

op_b = estado.get("opinion_grupo_b", _get_rango(cfg)["ejemplo_rechazo"])

nuevo = estado.copy()

nuevo["pertenencia_grupo"] = nuevo_perten

nuevo["opinion"] = _clip(

nuevo_perten * op_a + (1.0 - nuevo_perten) * op_b,

cfg,

)

time_series: np.ndarray,

prev_diagram: "np.ndarray | None",

embedding_dim: int = 2,

tau: int = 1,

wasserstein_threshold: float = 0.3,

) -> "tuple[bool, np.ndarray | None]":

"""

if not TDA_AVAILABLE:

return False, prev_diagram

min_len = embedding_dim * tau + 1

if len(time_series) < min_len:

return False, prev_diagram

n = len(time_series) - (embedding_dim - 1) * tau

embedded = np.array(

[time_series[i: i + embedding_dim * tau: tau] for i in range(n)],

dtype=float,

)

diagrams = ripser_compute(embedded, maxdim=1)["dgms"]

h1: np.ndarray = diagrams[1] if len(diagrams) > 1 else np.empty((0, 2))

if prev_diagram is None:

return False, h1

finite_prev = (

prev_diagram[np.isfinite(prev_diagram[:, 1])]

if len(prev_diagram) > 0

else np.empty((0, 2))

)

finite_curr = (

h1[np.isfinite(h1[:, 1])]

if len(h1) > 0

else np.empty((0, 2))

)

if len(finite_prev) == 0 and len(finite_curr) == 0:

return False, h1

dist = wasserstein_dist(finite_curr, finite_prev)

"campana": {

0: regla_lineal,

1: regla_umbral,

2: regla_memoria,

3: regla_backlash,

4: regla_polarizacion,

5: regla_hk,

6: regla_contagio_competitivo,

7: regla_umbral_heterogeneo,

8: regla_homofilia,

9: regla_replicador,

}

0: "lineal",

1: "umbral",

2: "memoria",

3: "backlash",

4: "polarizacion",

5: "hk",

6: "contagio_competitivo",

7: "umbral_heterogeneo",

8: "homofilia",

9: "replicador",

0: "Cambio proporcional suave",

1: "Salto al cruzar punto crítico",

2: "Inercia del estado pasado",

3: "Propaganda refuerza posición contraria",

4: "Aleja del neutro (cámara de eco)",

5: "Confianza acotada — solo escucha a similares (Hegselmann-Krause)",

6: "Dos narrativas compiten simultáneamente",

7: "Distribución de umbrales — cascadas sociales (Granovetter)",

8: "Red co-evolutiva — homofilia dinámica",

9: "Ecuación replicadora — dinámica evolutiva de estrategias (EGT)",

rangos = _RANGOS_PARAMS.get(regla_nombre, {})

return {

k: float(np.clip(v, *rangos[k])) if k in rangos and isinstance(v, (int, float)) else v

for k, v in params.items()

historial_reciente: list[dict], cfg: dict) -> str:

"""

es_bipolar = _es_bipolar(cfg)

tendencia = [round(h["opinion"], 3) for h in historial_reciente]

delta = round(tendencia[-1] - tendencia[0], 3) if len(tendencia) > 1 else 0.0

direccion = "rising" if delta > 0.02 else ("falling" if delta < -0.02 else "stable")

estado_fmt = {

k: round(v, 3) if isinstance(v, float) else v

for k, v in estado.items() if not k.startswith("_")

}

rango_desc = (

"[-1, 1]: 0=neutral, negative=active rejection, positive=support"

if es_bipolar else

"[0, 1]: 0.5=neutral, 0=total rejection, 1=total support"

)

ejemplos = """

base_prompt = f"""You are a rule selector for a social dynamics simulation.

ews_flags = estado.get("_ews_flags", {})

ews_context = ""

if ews_flags:

ews_context = (

f"\n[EWS] high_variance={ews_flags.get('high_variance', False)}, "

f"high_autocorr={ews_flags.get('high_autocorr', False)}, "

f"high_skewness={ews_flags.get('high_skewness', False)}. "

"These indicate proximity to a bifurcation tipping point "

"(B-tipping via Critical Slowing Down)."

)

inicio = texto.find("{")

fin = texto.rfind("}") + 1

if inicio == -1 or fin == 0:

return None

try:

return json.loads(texto[inicio:fin])

except json.JSONDecodeError:

modelo: str, cfg: dict) -> dict | None:

try: