tnfr 3.0.3__py3-none-any.whl → 8.5.0__py3-none-any.whl

tnfr/helpers.py

@@ -1,198 +0,0 @@
-"""
-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

@@ -1,37 +0,0 @@
-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/operators.py

@@ -1,296 +0,0 @@
-# operators.py — TNFR canónica (ASCII-safe)
-from __future__ import annotations
-from typing import Dict, Any, Optional
-import math
-import random
-import hashlib
-
-from constants import DEFAULTS, ALIAS_VF, ALIAS_THETA, ALIAS_DNFR, ALIAS_EPI, ALIAS_D2EPI
-from helpers import _get_attr, _set_attr, clamp, clamp01, list_mean, fase_media, push_glifo, invoke_callbacks
-
-"""
-Este módulo implementa:
-- Los 13 glifos como operadores locales suaves.
-- Un dispatcher `aplicar_glifo` que mapea el nombre del glifo (con apóstrofo tipográfico) a su función.
-- RE’MESH de red: `aplicar_remesh_red` y `aplicar_remesh_si_estabilizacion_global`.
-
-Nota sobre α (alpha) de RE’MESH: se toma por prioridad de
-1) G.graph["GLYPH_FACTORS"]["REMESH_alpha"]
-2) G.graph["REMESH_ALPHA"]
-3) DEFAULTS["REMESH_ALPHA"]
-"""
-
-# -------------------------
-# Glifos (operadores locales)
-# -------------------------
-
-def op_AL(G, n):  # A’L — Emisión
-    f = float(G.graph.get("GLYPH_FACTORS", DEFAULTS["GLYPH_FACTORS"]).get("AL_boost", 0.05))
-    nd = G.nodes[n]
-    epi = _get_attr(nd, ALIAS_EPI, 0.0)
-    _set_attr(nd, ALIAS_EPI, epi + f)
-
-
-def op_EN(G, n):  # E’N — Recepción
-    mix = float(G.graph.get("GLYPH_FACTORS", DEFAULTS["GLYPH_FACTORS"]).get("EN_mix", 0.25))
-    nd = G.nodes[n]
-    epi = _get_attr(nd, ALIAS_EPI, 0.0)
-    if G.degree(n) == 0:
-        return  # sin vecinos no hay mezcla
-    epi_bar = list_mean(_get_attr(G.nodes[v], ALIAS_EPI, epi) for v in G.neighbors(n))
-    _set_attr(nd, ALIAS_EPI, (1 - mix) * epi + mix * epi_bar)
-
-
-def op_IL(G, n):  # I’L — Coherencia (reduce ΔNFR)
-    factor = float(G.graph.get("GLYPH_FACTORS", DEFAULTS["GLYPH_FACTORS"]).get("IL_dnfr_factor", 0.7))
-    nd = G.nodes[n]
-    dnfr = _get_attr(nd, ALIAS_DNFR, 0.0)
-    _set_attr(nd, ALIAS_DNFR, factor * dnfr)
-
-def op_OZ(G, n):  # O’Z — Disonancia (aumenta ΔNFR o añade ruido)
-    factor = float(G.graph.get("GLYPH_FACTORS", DEFAULTS["GLYPH_FACTORS"]).get("OZ_dnfr_factor", 1.3))
-    nd = G.nodes[n]
-    dnfr = _get_attr(nd, ALIAS_DNFR, 0.0)
-    if bool(G.graph.get("OZ_NOISE_MODE", False)):
-        base_seed = int(G.graph.get("RANDOM_SEED", 0))
-        step_idx = len(G.graph.get("history", {}).get("C_steps", []))
-        rnd = random.Random(base_seed + step_idx*1000003 + hash(("OZ", n)) % 1009)
-        sigma = float(G.graph.get("OZ_SIGMA", 0.1))
-        noise = sigma * (2.0 * rnd.random() - 1.0)
-        _set_attr(nd, ALIAS_DNFR, dnfr + noise)
-    else:
-        _set_attr(nd, ALIAS_DNFR, factor * dnfr if abs(dnfr) > 1e-9 else 0.1)
-
-def op_UM(G, n):  # U’M — Acoplamiento (empuja fase a la media local)
-    k = float(G.graph.get("GLYPH_FACTORS", DEFAULTS["GLYPH_FACTORS"]).get("UM_theta_push", 0.25))
-    nd = G.nodes[n]
-    th = _get_attr(nd, ALIAS_THETA, 0.0)
-    thL = fase_media(G, n)
-    d = ((thL - th + math.pi) % (2 * math.pi) - math.pi)
-    _set_attr(nd, ALIAS_THETA, th + k * d)
-
-
-def op_RA(G, n):  # R’A — Resonancia (difusión EPI)
-    diff = float(G.graph.get("GLYPH_FACTORS", DEFAULTS["GLYPH_FACTORS"]).get("RA_epi_diff", 0.15))
-    nd = G.nodes[n]
-    epi = _get_attr(nd, ALIAS_EPI, 0.0)
-    if G.degree(n) == 0:
-        return
-    epi_bar = list_mean(_get_attr(G.nodes[v], ALIAS_EPI, epi) for v in G.neighbors(n))
-    _set_attr(nd, ALIAS_EPI, epi + diff * (epi_bar - epi))
-
-
-def op_SHA(G, n):  # SH’A — Silencio (baja νf)
-    factor = float(G.graph.get("GLYPH_FACTORS", DEFAULTS["GLYPH_FACTORS"]).get("SHA_vf_factor", 0.85))
-    nd = G.nodes[n]
-    vf = _get_attr(nd, ALIAS_VF, 0.0)
-    _set_attr(nd, ALIAS_VF, factor * vf)
-
-
-def op_VAL(G, n):  # VA’L — Expansión (escala EPI)
-    s = float(G.graph.get("GLYPH_FACTORS", DEFAULTS["GLYPH_FACTORS"]).get("VAL_scale", 1.15))
-    nd = G.nodes[n]
-    epi = _get_attr(nd, ALIAS_EPI, 0.0)
-    _set_attr(nd, ALIAS_EPI, s * epi)
-
-
-def op_NUL(G, n):  # NU’L — Contracción (escala EPI)
-    s = float(G.graph.get("GLYPH_FACTORS", DEFAULTS["GLYPH_FACTORS"]).get("NUL_scale", 0.85))
-    nd = G.nodes[n]
-    epi = _get_attr(nd, ALIAS_EPI, 0.0)
-    _set_attr(nd, ALIAS_EPI, s * epi)
-
-
-def op_THOL(G, n):  # T’HOL — Autoorganización (inyecta aceleración)
-    a = float(G.graph.get("GLYPH_FACTORS", DEFAULTS["GLYPH_FACTORS"]).get("THOL_accel", 0.10))
-    nd = G.nodes[n]
-    d2 = _get_attr(nd, ALIAS_D2EPI, 0.0)
-    _set_attr(nd, ALIAS_DNFR, _get_attr(nd, ALIAS_DNFR, 0.0) + a * d2)
-
-
-def op_ZHIR(G, n):  # Z’HIR — Mutación (desplaza fase)
-    shift = float(G.graph.get("GLYPH_FACTORS", DEFAULTS["GLYPH_FACTORS"]).get("ZHIR_theta_shift", 1.57079632679))
-    nd = G.nodes[n]
-    th = _get_attr(nd, ALIAS_THETA, 0.0)
-    _set_attr(nd, ALIAS_THETA, th + shift)
-
-def op_NAV(G, n):  # NA’V — Transición (jitter suave de ΔNFR)
-    nd = G.nodes[n]
-    dnfr = _get_attr(nd, ALIAS_DNFR, 0.0)
-    j = float(G.graph.get("GLYPH_FACTORS", DEFAULTS["GLYPH_FACTORS"]).get("NAV_jitter", 0.05))
-    if bool(G.graph.get("NAV_RANDOM", True)):
-        # jitter uniforme en [-j, j] con semilla reproducible
-        base_seed = int(G.graph.get("RANDOM_SEED", 0))
-        # opcional: pequeño offset para evitar misma secuencia en todos los nodos/pasos
-        step_idx = len(G.graph.get("history", {}).get("C_steps", []))
-        rnd = random.Random(base_seed + step_idx*1000003 + hash(n) % 1009)
-        jitter = j * (2.0 * rnd.random() - 1.0)
-    else:
-        # comportamiento determinista (compatibilidad previa)
-        jitter = j * (1 if dnfr >= 0 else -1)
-    _set_attr(nd, ALIAS_DNFR, dnfr + jitter)
-
-def op_REMESH(G, n):  # RE’MESH — se realiza a escala de red (no-op local con aviso)
-    # Loguea solo 1 vez por paso para no spamear
-    step_idx = len(G.graph.get("history", {}).get("C_steps", []))
-    last_warn = G.graph.get("_remesh_warn_step", None)
-    if last_warn != step_idx:
-        msg = "RE’MESH es a escala de red. Usa aplicar_remesh_si_estabilizacion_global(G) o aplicar_remesh_red(G)."
-        G.graph.setdefault("history", {}).setdefault("events", []).append(("warn", {"step": step_idx, "node": n, "msg": msg}))
-        G.graph["_remesh_warn_step"] = step_idx
-    # no cambia estado local
-    return
-
-# -------------------------
-# Dispatcher
-# -------------------------
-
-_NAME_TO_OP = {
-    "A’L": op_AL, "E’N": op_EN, "I’L": op_IL, "O’Z": op_OZ, "U’M": op_UM,
-    "R’A": op_RA, "SH’A": op_SHA, "VA’L": op_VAL, "NU’L": op_NUL,
-    "T’HOL": op_THOL, "Z’HIR": op_ZHIR, "NA’V": op_NAV, "RE’MESH": op_REMESH,
-}
-
-
-def aplicar_glifo(G, n, glifo: str, *, window: Optional[int] = None) -> None:
-    glifo = str(glifo)
-    op = _NAME_TO_OP.get(glifo)
-    if not op:
-        return
-    if window is None:
-        window = int(G.graph.get("GLYPH_HYSTERESIS_WINDOW", DEFAULTS["GLYPH_HYSTERESIS_WINDOW"]))
-    push_glifo(G.nodes[n], glifo, window)
-    op(G, n)
-
-
-# -------------------------
-# RE’MESH de red (usa _epi_hist capturado en dynamics.step)
-# -------------------------
-
-def _remesh_alpha_info(G):
-    """Devuelve (alpha, source) con precedencia explícita:
-    1) GLYPH_FACTORS["REMESH_alpha"]  2) G.graph["REMESH_ALPHA"]  3) DEFAULTS["REMESH_ALPHA"]"""
-    gf = G.graph.get("GLYPH_FACTORS", DEFAULTS["GLYPH_FACTORS"])
-    if "REMESH_alpha" in gf:
-        return float(gf["REMESH_alpha"]), "GLYPH_FACTORS"
-    if "REMESH_ALPHA" in G.graph:
-        return float(G.graph["REMESH_ALPHA"]), "G.graph"
-    return float(DEFAULTS["REMESH_ALPHA"]), "DEFAULTS"
-
-
-def aplicar_remesh_red(G) -> None:
-    """
-    RE’MESH a escala de red usando _epi_hist capturado en dynamics.step.
-    Loguea meta con alpha/tau/step + topo_hash y checksums/medias de EPI antes/después.
-    Precedencia de alpha: GLYPH_FACTORS → G.graph → DEFAULTS.
-    """
-    tau = int(G.graph.get("REMESH_TAU", DEFAULTS["REMESH_TAU"]))
-    alpha, alpha_src = _remesh_alpha_info(G)
-    hist = G.graph.get("_epi_hist", [])
-    if len(hist) < tau + 1:
-        return
-
-    past = hist[-(tau + 1)]
-
-    # --- Topología + snapshot EPI (ANTES) ---
-    try:
-        n_nodes = G.number_of_nodes()
-        n_edges = G.number_of_edges()
-        degs = sorted(d for _, d in G.degree())
-        topo_str = f"n={n_nodes};m={n_edges};deg=" + ",".join(map(str, degs))
-        topo_hash = hashlib.sha1(topo_str.encode()).hexdigest()[:12]
-    except Exception:
-        topo_hash = None
-
-    def _epi_items():
-        for node in G.nodes():
-            yield node, _get_attr(G.nodes[node], ALIAS_EPI, 0.0)
-
-    epi_mean_before = list_mean(v for _, v in _epi_items())
-    epi_checksum_before = hashlib.sha1(
-        str(sorted((str(k), round(v, 6)) for k, v in _epi_items())).encode()
-    ).hexdigest()[:12]
-
-    # --- Mezcla (1-α)·now + α·old ---
-    for n in G.nodes():
-        nd = G.nodes[n]
-        epi_now = _get_attr(nd, ALIAS_EPI, 0.0)
-        epi_old = float(past.get(n, epi_now))
-        _set_attr(nd, ALIAS_EPI, (1 - alpha) * epi_now + alpha * epi_old)
-
-    # --- Snapshot EPI (DESPUÉS) ---
-    epi_mean_after = list_mean(_get_attr(G.nodes[n], ALIAS_EPI, 0.0) for n in G.nodes())
-    epi_checksum_after = hashlib.sha1(
-        str(sorted((str(n), round(_get_attr(G.nodes[n], ALIAS_EPI, 0.0), 6)) for n in G.nodes())).encode()
-    ).hexdigest()[:12]
-
-    # --- Metadatos y logging de evento ---
-    step_idx = len(G.graph.get("history", {}).get("C_steps", []))
-    meta = {
-        "alpha": alpha,
-        "alpha_source": alpha_src,
-        "tau": tau,
-        "step": step_idx,
-        # firmas
-        "topo_hash": topo_hash,
-        "epi_mean_before": float(epi_mean_before),
-        "epi_mean_after": float(epi_mean_after),
-        "epi_checksum_before": epi_checksum_before,
-        "epi_checksum_after": epi_checksum_after,
-    }
-
-    # Snapshot opcional de métricas recientes
-    h = G.graph.get("history", {})
-    if h:
-        if h.get("stable_frac"): meta["stable_frac_last"] = h["stable_frac"][-1]
-        if h.get("phase_sync"):  meta["phase_sync_last"]  = h["phase_sync"][-1]
-        if h.get("glyph_load_disr"): meta["glyph_disr_last"] = h["glyph_load_disr"][-1]
-
-    G.graph["_REMESH_META"] = meta
-    if G.graph.get("REMESH_LOG_EVENTS", DEFAULTS["REMESH_LOG_EVENTS"]):
-        ev = G.graph.setdefault("history", {}).setdefault("remesh_events", [])
-        ev.append(dict(meta))
-
-    # Callbacks Γ(R)
-    invoke_callbacks(G, "on_remesh", dict(meta))
-
-def aplicar_remesh_si_estabilizacion_global(G, pasos_estables_consecutivos: Optional[int] = None) -> None:
-    # Ventanas y umbrales
-    w_estab = int(G.graph.get("REMESH_STABILITY_WINDOW", DEFAULTS["REMESH_STABILITY_WINDOW"]))
-    frac_req = float(G.graph.get("FRACTION_STABLE_REMESH", DEFAULTS["FRACTION_STABLE_REMESH"]))
-    req_extra = bool(G.graph.get("REMESH_REQUIRE_STABILITY", DEFAULTS["REMESH_REQUIRE_STABILITY"]))
-    min_sync = float(G.graph.get("REMESH_MIN_PHASE_SYNC", DEFAULTS["REMESH_MIN_PHASE_SYNC"]))
-    max_disr = float(G.graph.get("REMESH_MAX_GLYPH_DISR", DEFAULTS["REMESH_MAX_GLYPH_DISR"]))
-
-    hist = G.graph.setdefault("history", {"stable_frac": []})
-    sf = hist.get("stable_frac", [])
-    if len(sf) < w_estab:
-        return
-    # 1) Estabilidad por fracción de nodos estables
-    win_sf = sf[-w_estab:]
-    cond_sf = all(v >= frac_req for v in win_sf)
-    if not cond_sf:
-        return
-    # 2) Gating adicional (si está activado)
-    if req_extra:
-        # sincronía de fase (mayor mejor)
-        ps_ok = True
-        if "phase_sync" in hist and len(hist["phase_sync"]) >= w_estab:
-            win_ps = hist["phase_sync"][-w_estab:]
-            ps_ok = (sum(win_ps)/len(win_ps)) >= min_sync
-        # carga glífica disruptiva (menor mejor)
-        disr_ok = True
-        if "glyph_load_disr" in hist and len(hist["glyph_load_disr"]) >= w_estab:
-            win_disr = hist["glyph_load_disr"][-w_estab:]
-            disr_ok = (sum(win_disr)/len(win_disr)) <= max_disr
-        if not (ps_ok and disr_ok):
-            return
-    # 3) Cooldown
-    last = G.graph.get("_last_remesh_step", -10**9)
-    step_idx = len(sf)
-    cooldown = int(G.graph.get("REMESH_COOLDOWN_VENTANA", DEFAULTS["REMESH_COOLDOWN_VENTANA"]))
-    if step_idx - last < cooldown:
-        return
-    # 4) Aplicar y registrar
-    aplicar_remesh_red(G)
-    G.graph["_last_remesh_step"] = step_idx

tnfr-3.0.3.dist-info/METADATA

@@ -1,35 +0,0 @@
-Metadata-Version: 2.4
-Name: tnfr
-Version: 3.0.3
-Summary: TNFR canónica: dinámica glífica modular sobre redes.
-Author: Fer
-License: MIT
-Project-URL: Homepage, https://pypi.org/project/tnfr/
-Project-URL: Repository, https://github.com/fermga/Teoria-de-la-naturaleza-fractal-resonante-TNFR-
-Keywords: TNFR,fractal resonante,resonancia,glifos,networkx,dinámica,coherencia,EPI,Kuramoto
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Intended Audience :: Science/Research
-Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
-Classifier: Topic :: Scientific/Engineering :: Information Analysis
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-License-File: LICENSE.txt
-Requires-Dist: networkx>=2.6
-Dynamic: license-file
-
-# tnfr
-
-
-Paquete **tnfr** (canónica). Orquesta dinámica glífica sobre grafos `networkx`.
-
-
-```bash
-pip install tnfr

tnfr-3.0.3.dist-info/RECORD

@@ -1,13 +0,0 @@
-tnfr/__init__.py,sha256=TRSH_QpQJthBeGIUFVmxTBNyth5KqRrRfRBnTeGzA40,2012
-tnfr/constants.py,sha256=_775sPHussR9vgkWRCLC6dzwgk_1_lLnSlWT8sBWR3U,7677
-tnfr/dynamics.py,sha256=7B38c9SVKLVFBrKHeJ1nXbghoRHfDs8Nl9CqUmCcAyI,23260
-tnfr/helpers.py,sha256=tZJsDXc8k9HIfg8BA9cVUEFKBoX1Rfnuhurl2Fvxsy0,6017
-tnfr/main.py,sha256=TEngteuC9MD7Ec9bNGuCC9ym-2ohbh202-HGArCR4tk,1506
-tnfr/observers.py,sha256=MoC-xLJuMP-UYj8cpIVlgSbXDsE1Uj70Zy51PSH3AJY,5192
-tnfr/ontosim.py,sha256=U0IeNVF8rFNhnmWWux91xDc0djTDZQkqRRosP6Z7FmE,5485
-tnfr/operators.py,sha256=M6ahJL8IuB2y4qiEalge5EufCz0eEbhw-O4xfh3NpwE,12146
-tnfr-3.0.3.dist-info/licenses/LICENSE.txt,sha256=xTjBNhy3N8pomFljrCkD1d34SmAEWv8hyJMMOjNMH0M,1071
-tnfr-3.0.3.dist-info/METADATA,sha256=aZbWmWTeChR9K_uZSOizMzwggsi5Kv2pQ6Apu58ut8I,1325
-tnfr-3.0.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-tnfr-3.0.3.dist-info/top_level.txt,sha256=Q2HJnvc5Rt2VHwVvyBTnNPT4SfmJWnCj7XUxxEvQa7c,5
-tnfr-3.0.3.dist-info/RECORD,,