tnfr 1.0__py3-none-any.whl → 3.0.0__py3-none-any.whl

tnfr/helpers.py

@@ -0,0 +1,198 @@
+"""
+helpers.py — TNFR canónica
+
+Utilidades transversales + cálculo de Índice de sentido (Si).
+"""
+from __future__ import annotations
+from typing import Iterable, Dict, Any, Tuple, List
+import math
+from collections import deque
+
+try:
+    import networkx as nx  # solo para tipos
+except Exception:  # pragma: no cover
+    nx = None  # type: ignore
+
+from constants import DEFAULTS, ALIAS_VF, ALIAS_THETA, ALIAS_DNFR, ALIAS_EPI, ALIAS_SI
+
+# -------------------------
+# Utilidades numéricas
+# -------------------------
+
+def clamp(x: float, a: float, b: float) -> float:
+    return a if x < a else b if x > b else x
+
+
+def clamp_abs(x: float, m: float) -> float:
+    m = abs(m)
+    return clamp(x, -m, m)
+
+
+def clamp01(x: float) -> float:
+    return clamp(x, 0.0, 1.0)
+
+
+def list_mean(xs: Iterable[float], default: float = 0.0) -> float:
+    xs = list(xs)
+    return sum(xs) / len(xs) if xs else default
+
+
+def _wrap_angle(a: float) -> float:
+    """Envuelve ángulo a (-π, π]."""
+    pi = math.pi
+    a = (a + pi) % (2 * pi) - pi
+    return a
+
+
+def phase_distance(a: float, b: float) -> float:
+    """Distancia de fase normalizada en [0,1]. 0 = misma fase, 1 = opuesta."""
+    return abs(_wrap_angle(a - b)) / math.pi
+
+
+# -------------------------
+# Acceso a atributos con alias
+# -------------------------
+
+def _get_attr(d: Dict[str, Any], aliases: Iterable[str], default: float = 0.0) -> float:
+    for k in aliases:
+        if k in d:
+            try:
+                return float(d[k])
+            except Exception:
+                continue
+    return float(default)
+
+def _set_attr(d, aliases, value: float) -> None:
+    for k in aliases:
+        if k in d:
+            d[k] = float(value)
+            return
+    d[next(iter(aliases))] = float(value)
+
+# -------------------------
+# Estadísticos vecinales
+# -------------------------
+
+def media_vecinal(G, n, aliases: Iterable[str], default: float = 0.0) -> float:
+    vals: List[float] = []
+    for v in G.neighbors(n):
+        vals.append(_get_attr(G.nodes[v], aliases, default))
+    return list_mean(vals, default)
+
+
+def fase_media(G, n) -> float:
+    """Promedio circular de las fases de los vecinos."""
+    import math
+    x = 0.0
+    y = 0.0
+    count = 0
+    for v in G.neighbors(n):
+        th = _get_attr(G.nodes[v], ALIAS_THETA, 0.0)
+        x += math.cos(th)
+        y += math.sin(th)
+        count += 1
+    if count == 0:
+        return _get_attr(G.nodes[n], ALIAS_THETA, 0.0)
+    return math.atan2(y / max(1, count), x / max(1, count))
+
+
+# -------------------------
+# Historial de glifos por nodo
+# -------------------------
+
+def push_glifo(nd: Dict[str, Any], glifo: str, window: int) -> None:
+    hist = nd.setdefault("hist_glifos", deque(maxlen=window))
+    hist.append(str(glifo))
+
+
+def reciente_glifo(nd: Dict[str, Any], glifo: str, ventana: int) -> bool:
+    hist = nd.get("hist_glifos")
+    if not hist:
+        return False
+    last = list(hist)[-ventana:]
+    return str(glifo) in last
+
+# -------------------------
+# Callbacks Γ(R)
+# -------------------------
+
+def _ensure_callbacks(G):
+    """Garantiza la estructura de callbacks en G.graph."""
+    cbs = G.graph.setdefault("callbacks", {
+        "before_step": [],
+        "after_step": [],
+        "on_remesh": [],
+    })
+    # normaliza claves por si vienen incompletas
+    for k in ("before_step", "after_step", "on_remesh"):
+        cbs.setdefault(k, [])
+    return cbs
+
+def register_callback(G, event: str, func):
+    """Registra un callback en G.graph['callbacks'][event]. Firma: func(G, ctx) -> None"""
+    if event not in ("before_step", "after_step", "on_remesh"):
+        raise ValueError(f"Evento desconocido: {event}")
+    cbs = _ensure_callbacks(G)
+    cbs[event].append(func)
+    return func
+
+def invoke_callbacks(G, event: str, ctx: dict | None = None):
+    """Invoca todos los callbacks registrados para `event` con el contexto `ctx`."""
+    cbs = _ensure_callbacks(G).get(event, [])
+    strict = bool(G.graph.get("CALLBACKS_STRICT", DEFAULTS["CALLBACKS_STRICT"]))
+    ctx = ctx or {}
+    for fn in list(cbs):
+        try:
+            fn(G, ctx)
+        except Exception as e:
+            if strict:
+                raise
+            G.graph.setdefault("_callback_errors", []).append({
+                "event": event, "step": ctx.get("step"), "error": repr(e), "fn": repr(fn)
+            })
+
+# -------------------------
+# Índice de sentido (Si)
+# -------------------------
+
+def compute_Si(G, *, inplace: bool = True) -> Dict[Any, float]:
+    """Calcula Si por nodo y lo escribe en G.nodes[n]["Si"].
+
+    Si = α·νf_norm + β·(1 - disp_fase_local) + γ·(1 - |ΔNFR|/max|ΔNFR|)
+    """
+    alpha = float(G.graph.get("SI_WEIGHTS", DEFAULTS["SI_WEIGHTS"]).get("alpha", 0.34))
+    beta = float(G.graph.get("SI_WEIGHTS", DEFAULTS["SI_WEIGHTS"]).get("beta", 0.33))
+    gamma = float(G.graph.get("SI_WEIGHTS", DEFAULTS["SI_WEIGHTS"]).get("gamma", 0.33))
+    s = alpha + beta + gamma
+    if s <= 0:
+        alpha = beta = gamma = 1/3
+    else:
+        alpha, beta, gamma = alpha/s, beta/s, gamma/s
+
+    # Normalización de νf en red
+    vfs = [abs(_get_attr(G.nodes[n], ALIAS_VF, 0.0)) for n in G.nodes()]
+    vfmax = max(vfs) if vfs else 1.0
+    # Normalización de ΔNFR
+    dnfrs = [abs(_get_attr(G.nodes[n], ALIAS_DNFR, 0.0)) for n in G.nodes()]
+    dnfrmax = max(dnfrs) if dnfrs else 1.0
+
+    out: Dict[Any, float] = {}
+    for n in G.nodes():
+        nd = G.nodes[n]
+        vf = _get_attr(nd, ALIAS_VF, 0.0)
+        vf_norm = 0.0 if vfmax == 0 else clamp01(abs(vf)/vfmax)
+
+        # dispersión de fase local
+        th_i = _get_attr(nd, ALIAS_THETA, 0.0)
+        th_bar = fase_media(G, n)
+        disp_fase = phase_distance(th_i, th_bar)  # [0,1]
+
+        dnfr = _get_attr(nd, ALIAS_DNFR, 0.0)
+        dnfr_norm = 0.0 if dnfrmax == 0 else clamp01(abs(dnfr)/dnfrmax)
+
+        Si = alpha*vf_norm + beta*(1.0 - disp_fase) + gamma*(1.0 - dnfr_norm)
+        Si = clamp01(Si)
+        out[n] = Si
+        if inplace:
+            _set_attr(nd, ALIAS_SI, Si)
+    return out

tnfr/main.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+import argparse, sys
+import networkx as nx
+from . import preparar_red, run, __version__
+
+def main(argv: list[str] | None = None) -> None:
+    p = argparse.ArgumentParser(
+        prog="tnfr",
+        description="TNFR canónica — demo CLI (red Erdős–Rényi + dinámica glífica)",
+    )
+    p.add_argument("--version", action="store_true", help="muestra versión y sale")
+    p.add_argument("--n", type=int, default=30, help="nodos (Erdős–Rényi)")
+    p.add_argument("--p", type=float, default=0.15, help="probabilidad de arista (Erdős–Rényi)")
+    p.add_argument("--steps", type=int, default=100, help="pasos a simular")
+    p.add_argument("--observer", action="store_true", help="adjunta observador estándar")
+    args = p.parse_args(argv)
+
+    if args.version:
+        print(__version__)
+        return
+
+    G = nx.erdos_renyi_graph(args.n, args.p)
+    preparar_red(G, ATTACH_STD_OBSERVER=bool(args.observer))
+    run(G, args.steps)
+
+    h = G.graph.get("history", {})
+    C = h.get("C_steps", [])[-1] if h.get("C_steps") else None
+    stab = h.get("stable_frac", [])[-1] if h.get("stable_frac") else None
+    R = h.get("kuramoto_R", [])[-1] if h.get("kuramoto_R") else None
+
+    print("TNFR terminado:")
+    if C is not None: print(f" C(t) ~ {C:.3f}")
+    if stab is not None: print(f" estable ~ {stab:.3f}")
+    if R is not None: print(f" R (Kuramoto) ~ {R:.3f}")
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

tnfr/observers.py

@@ -0,0 +1,149 @@
+"""
+observers.py — TNFR canónica
+
+Observadores y métricas auxiliares.
+"""
+from __future__ import annotations
+from collections import Counter
+from typing import Dict, Any
+import math
+
+from constants import ALIAS_DNFR, ALIAS_EPI, ALIAS_THETA, ALIAS_dEPI
+from helpers import _get_attr, list_mean, register_callback
+
+# -------------------------
+# Observador estándar Γ(R)
+# -------------------------
+def _std_log(G, kind: str, ctx: dict):
+    """Guarda eventos compactos en history['events']."""
+    h = G.graph.setdefault("history", {})
+    h.setdefault("events", []).append((kind, dict(ctx)))
+
+def std_before(G, ctx):
+    _std_log(G, "before", ctx)
+
+def std_after(G, ctx):
+    _std_log(G, "after", ctx)
+
+def std_on_remesh(G, ctx):
+    _std_log(G, "remesh", ctx)
+
+def attach_standard_observer(G):
+    """Registra callbacks estándar: before_step, after_step, on_remesh."""
+    register_callback(G, "before_step", std_before)
+    register_callback(G, "after_step",  std_after)
+    register_callback(G, "on_remesh",   std_on_remesh)
+    G.graph.setdefault("_STD_OBSERVER", "attached")
+    return G
+
+def coherencia_global(G) -> float:
+    """Proxy de C(t): alta cuando |ΔNFR| y |dEPI_dt| son pequeños."""
+    dnfr = list_mean(abs(_get_attr(G.nodes[n], ALIAS_DNFR, 0.0)) for n in G.nodes())
+    dEPI = list_mean(abs(_get_attr(G.nodes[n], ALIAS_dEPI, 0.0)) for n in G.nodes())
+    return 1.0 / (1.0 + dnfr + dEPI)
+
+
+def sincronía_fase(G) -> float:
+    X = list(math.cos(_get_attr(G.nodes[n], ALIAS_THETA, 0.0)) for n in G.nodes())
+    Y = list(math.sin(_get_attr(G.nodes[n], ALIAS_THETA, 0.0)) for n in G.nodes())
+    if not X:
+        return 1.0
+    import math
+    th = math.atan2(sum(Y)/len(Y), sum(X)/len(X))
+    # varianza angular aproximada (0 = muy sincronizado)
+    import statistics as st
+    var = st.pvariance([((_get_attr(G.nodes[n], ALIAS_THETA, 0.0) - th + math.pi) % (2*math.pi) - math.pi) for n in G.nodes()]) if len(X) > 1 else 0.0
+    return 1.0 / (1.0 + var)
+
+def orden_kuramoto(G) -> float:
+    """R en [0,1], 1 = fases perfectamente alineadas."""
+    X = [math.cos(_get_attr(G.nodes[n], ALIAS_THETA, 0.0)) for n in G.nodes()]
+    Y = [math.sin(_get_attr(G.nodes[n], ALIAS_THETA, 0.0)) for n in G.nodes()]
+    if not X:
+        return 1.0
+    R = ((sum(X)**2 + sum(Y)**2) ** 0.5) / max(1, len(X))
+    return float(R)
+
+def carga_glifica(G, window: int | None = None) -> dict:
+    """Devuelve distribución de glifos aplicados en la red.
+    - window: si se indica, cuenta solo los últimos `window` eventos por nodo; si no, usa el maxlen del deque.
+    Retorna un dict con proporciones por glifo y agregados útiles.
+    """
+    total = Counter()
+    for n in G.nodes():
+        nd = G.nodes[n]
+        hist = nd.get("hist_glifos")
+        if not hist:
+            continue
+        seq = list(hist)
+        if window is not None and window > 0:
+            seq = seq[-window:]
+        total.update(seq)
+
+
+    count = sum(total.values())
+    if count == 0:
+        return {"_count": 0}
+
+
+    # Proporciones por glifo
+    dist = {k: v / count for k, v in total.items()}
+
+
+    # Agregados conceptuales (puedes ajustar categorías)
+    estabilizadores = ["I’L", "R’A", "U’M", "SH’A"]
+    disruptivos = ["O’Z", "Z’HIR", "NA’V", "T’HOL"]
+
+
+    dist["_estabilizadores"] = sum(dist.get(k, 0.0) for k in estabilizadores)
+    dist["_disruptivos"] = sum(dist.get(k, 0.0) for k in disruptivos)
+    dist["_count"] = count
+    return dist
+
+def sigma_vector(G, window: int | None = None) -> dict:
+    """Vector de sentido Σ⃗ a partir de la distribución glífica reciente.
+    Devuelve dict con x, y, mag (0..1) y angle (rad)."""
+    # Distribución glífica (proporciones)
+    dist = carga_glifica(G, window=window)
+    if not dist or dist.get("_count", 0) == 0:
+        return {"x": 0.0, "y": 0.0, "mag": 0.0, "angle": 0.0}
+
+    # Mapeo polar de glifos principales en el plano de sentido
+    # (ordenado estabilización→expansión→acoplamiento→silencio→disonancia→mutación→transición→autoorg.)
+    angles = {
+        "I’L": 0.0,
+        "R’A": math.pi/4,
+        "U’M": math.pi/2,
+        "SH’A": 3*math.pi/4,
+        "O’Z": math.pi,
+        "Z’HIR": 5*math.pi/4,
+        "NA’V": 3*math.pi/2,
+        "T’HOL": 7*math.pi/4,
+    }
+    # Normaliza solo sobre glifos mapeados
+    total = sum(dist.get(k, 0.0) for k in angles.keys())
+    if total <= 0:
+        return {"x": 0.0, "y": 0.0, "mag": 0.0, "angle": 0.0}
+
+    x = 0.0
+    y = 0.0
+    for k, a in angles.items():
+        p = dist.get(k, 0.0) / total
+        x += p * math.cos(a)
+        y += p * math.sin(a)
+
+    mag = (x*x + y*y) ** 0.5
+    ang = math.atan2(y, x)
+    return {"x": float(x), "y": float(y), "mag": float(mag), "angle": float(ang)}
+
+def wbar(G, window: int | None = None) -> float:
+    """Devuelve W̄ = media de C(t) en una ventana reciente."""
+    hist = G.graph.get("history", {})
+    cs = hist.get("C_steps", [])
+    if not cs:
+        # fallback: coherencia instantánea
+        return coherencia_global(G)
+    if window is None:
+        window = int(G.graph.get("WBAR_WINDOW", 25))
+    w = min(len(cs), max(1, int(window)))
+    return float(sum(cs[-w:]) / w)

tnfr/ontosim.py

@@ -0,0 +1,137 @@
+"""
+ontosim.py — TNFR canónica
+
+Módulo de orquestación mínima que encadena:
+ΔNFR (campo) → Si → glifos → ecuación nodal → clamps → U’M → observadores → RE’MESH
+"""
+from __future__ import annotations
+import networkx as nx
+import math
+import random
+
+from constants import DEFAULTS, attach_defaults
+from dynamics import step as _step, run as _run
+from dynamics import default_compute_delta_nfr
+
+# API de alto nivel
+
+def preparar_red(G: nx.Graph, *, override_defaults: bool = False, **overrides) -> nx.Graph:
+    attach_defaults(G, override=override_defaults)
+    if overrides:
+        from constants import merge_overrides
+        merge_overrides(G, **overrides)
+    # Inicializaciones blandas
+    G.graph.setdefault("history", {
+        "C_steps": [],
+        "stable_frac": [],
+        "phase_sync": [],
+        "kuramoto_R": [], 
+        "sense_sigma_x": [],
+        "sense_sigma_y": [],
+        "sense_sigma_mag": [],
+        "sense_sigma_angle": [],
+        "iota": [],
+        "glyph_load_estab": [],
+        "glyph_load_disr": [],
+        "Si_mean": [],
+        "Si_hi_frac": [],
+        "Si_lo_frac": [],
+        "W_bar": [],
+        "phase_kG": [],
+        "phase_kL": [], 
+        "phase_state": [],
+        "phase_R": [], 
+        "phase_disr": [],
+    })
+    G.graph.setdefault("_epi_hist", [])
+    # Auto-attach del observador estándar si se pide
+    if G.graph.get("ATTACH_STD_OBSERVER", False):
+        try:
+            from observers import attach_standard_observer
+            attach_standard_observer(G)
+        except Exception as e:
+            G.graph.setdefault("_callback_errors", []).append(
+                {"event":"attach_std_observer","error":repr(e)}
+            )
+    # Hook explícito para ΔNFR (se puede sustituir luego con dynamics.set_delta_nfr_hook)
+    G.graph.setdefault("compute_delta_nfr", default_compute_delta_nfr)
+    G.graph.setdefault("_dnfr_hook_name", "default_compute_delta_nfr")
+    # Callbacks Γ(R): before_step / after_step / on_remesh
+    G.graph.setdefault("callbacks", {
+        "before_step": [],
+        "after_step": [],
+        "on_remesh": [],
+    })
+    G.graph.setdefault("_CALLBACKS_DOC",
+        "Interfaz Γ(R): registrar funciones (G, ctx) en callbacks['before_step'|'after_step'|'on_remesh']")
+    
+    # --- Inicialización configurable de θ y νf ---
+    seed = int(G.graph.get("RANDOM_SEED", 0))
+    init_rand_phase = bool(G.graph.get("INIT_RANDOM_PHASE", DEFAULTS.get("INIT_RANDOM_PHASE", True)))
+
+    th_min = float(G.graph.get("INIT_THETA_MIN",  DEFAULTS.get("INIT_THETA_MIN", -math.pi)))
+    th_max = float(G.graph.get("INIT_THETA_MAX",  DEFAULTS.get("INIT_THETA_MAX",  math.pi)))
+
+    vf_mode = str(G.graph.get("INIT_VF_MODE", DEFAULTS.get("INIT_VF_MODE", "uniform"))).lower()
+    vf_min_lim = float(G.graph.get("VF_MIN", DEFAULTS["VF_MIN"]))
+    vf_max_lim = float(G.graph.get("VF_MAX", DEFAULTS["VF_MAX"]))
+
+    vf_uniform_min = G.graph.get("INIT_VF_MIN", DEFAULTS.get("INIT_VF_MIN", None))
+    vf_uniform_max = G.graph.get("INIT_VF_MAX", DEFAULTS.get("INIT_VF_MAX", None))
+    if vf_uniform_min is None: vf_uniform_min = vf_min_lim
+    if vf_uniform_max is None: vf_uniform_max = vf_max_lim
+
+    vf_mean = float(G.graph.get("INIT_VF_MEAN", DEFAULTS.get("INIT_VF_MEAN", 0.5)))
+    vf_std  = float(G.graph.get("INIT_VF_STD",  DEFAULTS.get("INIT_VF_STD",  0.15)))
+    clamp_to_limits = bool(G.graph.get("INIT_VF_CLAMP_TO_LIMITS", DEFAULTS.get("INIT_VF_CLAMP_TO_LIMITS", True)))
+
+    for idx, n in enumerate(G.nodes()):
+        nd = G.nodes[n]
+        # EPI canónico
+        nd.setdefault("EPI", 0.0)
+
+        # θ aleatoria (opt-in por flag)
+        if init_rand_phase:
+            th_rng = random.Random(seed + 1009 * idx)
+            nd["θ"] = th_rng.uniform(th_min, th_max)
+        else:
+            nd.setdefault("θ", 0.0)
+
+        # νf distribuida
+        if vf_mode == "uniform":
+            vf_rng = random.Random(seed * 1000003 + idx)
+            vf = vf_rng.uniform(float(vf_uniform_min), float(vf_uniform_max))
+        elif vf_mode == "normal":
+            vf_rng = random.Random(seed * 1000003 + idx)
+            # normal truncada simple (rechazo)
+            for _ in range(16):
+                cand = vf_rng.normalvariate(vf_mean, vf_std)
+                if vf_min_lim <= cand <= vf_max_lim:
+                    vf = cand
+                    break
+            else:
+                # fallback: clamp del último candidato
+                vf = min(max(vf_rng.normalvariate(vf_mean, vf_std), vf_min_lim), vf_max_lim)
+        else:
+            # fallback: conserva si existe, si no 0.5
+            vf = float(nd.get("νf", 0.5))
+
+        if clamp_to_limits:
+            vf = min(max(vf, vf_min_lim), vf_max_lim)
+
+        nd["νf"] = float(vf)
+        
+    return G
+
+def step(G: nx.Graph, *, dt: float | None = None, use_Si: bool = True, apply_glyphs: bool = True) -> None:
+    _step(G, dt=dt, use_Si=use_Si, apply_glyphs=apply_glyphs)
+
+def run(G: nx.Graph, steps: int, *, dt: float | None = None, use_Si: bool = True, apply_glyphs: bool = True) -> None:
+    _run(G, steps=steps, dt=dt, use_Si=use_Si, apply_glyphs=apply_glyphs)
+
+# Helper rápido para pruebas manuales
+if __name__ == "__main__":
+    G = nx.erdos_renyi_graph(30, 0.15)
+    preparar_red(G)
+    run(G, 100)
+    print("C(t) muestras:", G.graph["history"]["C_steps"][-5:])