tnfr 4.0.0__py3-none-any.whl → 4.3.0__py3-none-any.whl

tnfr/gamma.py

@@ -3,10 +3,19 @@
 Γi(R): acoplamientos de red para la ecuación nodal extendida
     ∂EPI/∂t = νf · ΔNFR(t) + Γi(R)
 
+`Γ` suma un término de acoplamiento dependiente del orden global de fase
+`R`. La especificación se toma de ``G.graph['GAMMA']`` (ver
+``DEFAULTS['GAMMA']``) con parámetros como:
+
+* ``type`` – modo de acoplamiento (``none``, ``kuramoto_linear``,
+  ``kuramoto_bandpass``)
+* ``beta`` – ganancia del acoplamiento
+* ``R0`` – umbral de activación (solo lineal)
+
 Provee:
 - kuramoto_R_psi(G): (R, ψ) orden de Kuramoto en la red
 - GAMMA_REGISTRY: registro de acoplamientos canónicos
-- eval_gamma(G, node, t): evalúa Γ para cada nodo según G.graph['GAMMA']
+- eval_gamma(G, node, t): evalúa Γ para cada nodo según la config
 """
 from __future__ import annotations
 from typing import Dict, Any, Tuple
@@ -14,14 +23,7 @@ import math
 import cmath
 
 from .constants import ALIAS_THETA
-
-
-def _get_attr(nd: Dict[str, Any], aliases, default: float = 0.0) -> float:
-    """Obtiene el primer atributo presente en nd según aliases."""
-    for k in aliases:
-        if k in nd:
-            return nd[k]
-    return default
+from .helpers import _get_attr
 
 
 def kuramoto_R_psi(G) -> Tuple[float, float]:
@@ -74,10 +76,27 @@ def gamma_kuramoto_bandpass(G, node, t, cfg: Dict[str, Any]) -> float:
     return beta * R * (1.0 - R) * sgn
 
 
+def gamma_kuramoto_tanh(G, node, t, cfg: Dict[str, Any]) -> float:
+    """Acoplamiento saturante tipo tanh para Γi(R).
+
+    Fórmula: Γ = β · tanh(k·(R - R0)) · cos(θ_i - ψ)
+      - β: ganancia del acoplamiento
+      - k: pendiente de la tanh (cuán rápido satura)
+      - R0: umbral de activación
+    """
+    beta = float(cfg.get("beta", 0.0))
+    k = float(cfg.get("k", 1.0))
+    R0 = float(cfg.get("R0", 0.0))
+    R, psi = kuramoto_R_psi(G)
+    th_i = _get_attr(G.nodes[node], ALIAS_THETA, 0.0)
+    return beta * math.tanh(k * (R - R0)) * math.cos(th_i - psi)
+
+
 GAMMA_REGISTRY = {
     "none": gamma_none,
     "kuramoto_linear": gamma_kuramoto_linear,
     "kuramoto_bandpass": gamma_kuramoto_bandpass,
+    "kuramoto_tanh": gamma_kuramoto_tanh,
 }
 
 

tnfr/grammar.py

@@ -142,6 +142,12 @@ def on_applied_glifo(G, n, applied: str) -> None:
 # -------------------------
 
 def select_and_apply_with_grammar(G, n, selector, window: int) -> None:
+    """Aplica gramática canónica sobre la propuesta del selector.
+
+    El selector puede incluir una gramática **suave** (pre–filtro) como
+    `parametric_glyph_selector`; la presente función garantiza que la
+    gramática canónica tenga precedencia final.
+    """
     from .operators import aplicar_glifo
     cand = selector(G, n)
     cand = enforce_canonical_grammar(G, n, cand)

tnfr/helpers.py

@@ -124,6 +124,27 @@ def reciente_glifo(nd: Dict[str, Any], glifo: str, ventana: int) -> bool:
             break
     return False
 
+# -------------------------
+# Utilidades de historial global
+# -------------------------
+
+def ensure_history(G) -> Dict[str, Any]:
+    """Garantiza G.graph['history'] y la devuelve."""
+    if "history" not in G.graph:
+        G.graph["history"] = {}
+    return G.graph["history"]
+
+
+def last_glifo(nd: Dict[str, Any]) -> str | None:
+    """Retorna el glifo más reciente del nodo o ``None``."""
+    hist = nd.get("hist_glifos")
+    if not hist:
+        return None
+    try:
+        return list(hist)[-1]
+    except Exception:
+        return None
+
 # -------------------------
 # Callbacks Γ(R)
 # -------------------------
@@ -186,7 +207,10 @@ def invoke_callbacks(G, event: str, ctx: dict | None = None):
 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|)
+    Fórmula:
+        Si = α·νf_norm + β·(1 - disp_fase_local) + γ·(1 - |ΔNFR|/max|ΔNFR|)
+    También guarda en ``G.graph`` los pesos normalizados y la
+    sensibilidad parcial (∂Si/∂componente).
     """
     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))
@@ -196,6 +220,8 @@ def compute_Si(G, *, inplace: bool = True) -> Dict[Any, float]:
         alpha = beta = gamma = 1/3
     else:
         alpha, beta, gamma = alpha/s, beta/s, gamma/s
+    G.graph["_Si_weights"] = {"alpha": alpha, "beta": beta, "gamma": gamma}
+    G.graph["_Si_sensitivity"] = {"dSi_dvf_norm": alpha, "dSi_ddisp_fase": -beta, "dSi_ddnfr_norm": -gamma}
 
     # Normalización de νf en red
     vfs = [abs(_get_attr(G.nodes[n], ALIAS_VF, 0.0)) for n in G.nodes()]

tnfr/metrics.py

@@ -2,9 +2,11 @@ from __future__ import annotations
 from typing import Dict, Any, List, Tuple
 from collections import defaultdict, Counter
 import statistics
+import csv
+import json
 
 from .constants import DEFAULTS
-from .helpers import _get_attr, clamp01, register_callback
+from .helpers import register_callback, ensure_history, last_glifo
 from .sense import GLYPHS_CANONICAL
 
 # -------------
@@ -16,25 +18,12 @@ DEFAULTS.setdefault("METRICS", {
     "normalize_series": False # glifograma normalizado a fracción por paso
 })
 
+    
+    
 # -------------
 # Utilidades internas
 # -------------
 
-def _ensure_history(G):
-    if "history" not in G.graph:
-        G.graph["history"] = {}
-    return G.graph["history"]
-
-
-def _last_glifo(nd: Dict[str, Any]) -> str | None:
-    hist = nd.get("hist_glifos")
-    if not hist:
-        return None
-    try:
-        return list(hist)[-1]
-    except Exception:
-        return None
-
 
 # -------------
 # Estado nodal para Tg
@@ -44,10 +33,7 @@ def _tg_state(nd: Dict[str, Any]) -> Dict[str, Any]:
     """Estructura interna por nodo para acumular tiempos de corrida por glifo.
     Campos: curr (glifo actual), run (tiempo acumulado en el glifo actual)
     """
-    st = nd.setdefault("_Tg", {"curr": None, "run": 0.0})
-    st.setdefault("curr", None)
-    st.setdefault("run", 0.0)
-    return st
+    return nd.setdefault("_Tg", {"curr": None, "run": 0.0})
 
 
 # -------------
@@ -66,7 +52,7 @@ def _metrics_step(G, *args, **kwargs):
     if not G.graph.get("METRICS", DEFAULTS.get("METRICS", {})).get("enabled", True):
         return
 
-    hist = _ensure_history(G)
+    hist = ensure_history(G)
     dt = float(G.graph.get("DT", 1.0))
     t = float(G.graph.get("_t", 0.0))
 
@@ -84,7 +70,7 @@ def _metrics_step(G, *args, **kwargs):
 
     for n in G.nodes():
         nd = G.nodes[n]
-        g = _last_glifo(nd)
+        g = last_glifo(nd)
         if not g:
             continue
 
@@ -143,7 +129,7 @@ def register_metrics_callbacks(G) -> None:
 
 def Tg_global(G, normalize: bool = True) -> Dict[str, float]:
     """Tiempo glífico total por clase. Si normalize=True, devuelve fracciones del total."""
-    hist = _ensure_history(G)
+    hist = ensure_history(G)
     tg_total: Dict[str, float] = hist.get("Tg_total", {})
     total = sum(tg_total.values()) or 1.0
     if normalize:
@@ -153,7 +139,7 @@ def Tg_global(G, normalize: bool = True) -> Dict[str, float]:
 
 def Tg_by_node(G, n, normalize: bool = False) -> Dict[str, float | List[float]]:
     """Resumen por nodo: si normalize, devuelve medias por glifo; si no, lista de corridas."""
-    hist = _ensure_history(G)
+    hist = ensure_history(G)
     rec = hist.get("Tg_by_node", {}).get(n, {})
     if not normalize:
         # convertir default dict → list para serializar
@@ -167,7 +153,7 @@ def Tg_by_node(G, n, normalize: bool = False) -> Dict[str, float | List[float]]:
 
 
 def latency_series(G) -> Dict[str, List[float]]:
-    hist = _ensure_history(G)
+    hist = ensure_history(G)
     xs = hist.get("latency_index", [])
     return {
         "t": [float(x.get("t", i)) for i, x in enumerate(xs)],
@@ -176,7 +162,7 @@ def latency_series(G) -> Dict[str, List[float]]:
 
 
 def glifogram_series(G) -> Dict[str, List[float]]:
-    hist = _ensure_history(G)
+    hist = ensure_history(G)
     xs = hist.get("glifogram", [])
     if not xs:
         return {"t": []}
@@ -194,7 +180,7 @@ def glyph_top(G, k: int = 3) -> List[Tuple[str, float]]:
 
 def glyph_dwell_stats(G, n) -> Dict[str, Dict[str, float]]:
     """Estadísticos por nodo: mean/median/max de corridas por glifo."""
-    hist = _ensure_history(G)
+    hist = ensure_history(G)
     rec = hist.get("Tg_by_node", {}).get(n, {})
     out = {}
     for g in GLYPHS_CANONICAL:
@@ -209,3 +195,40 @@ def glyph_dwell_stats(G, n) -> Dict[str, Dict[str, float]]:
                 "count": int(len(runs)),
             }
     return out
+
+
+# -----------------------------
+# Export history to CSV/JSON
+# -----------------------------
+
+def export_history(G, base_path: str, fmt: str = "csv") -> None:
+    """Vuelca glifograma y traza σ(t) a archivos CSV o JSON compactos."""
+    hist = ensure_history(G)
+    glifo = glifogram_series(G)
+    sigma_mag = hist.get("sense_sigma_mag", [])
+    sigma = {
+        "t": list(range(len(sigma_mag))),
+        "sigma_x": hist.get("sense_sigma_x", []),
+        "sigma_y": hist.get("sense_sigma_y", []),
+        "mag": sigma_mag,
+        "angle": hist.get("sense_sigma_angle", []),
+    }
+    fmt = fmt.lower()
+    if fmt == "csv":
+        with open(base_path + "_glifogram.csv", "w", newline="") as f:
+            writer = csv.writer(f)
+            writer.writerow(["t", *GLYPHS_CANONICAL])
+            ts = glifo.get("t", [])
+            default_col = [0] * len(ts)
+            for i, t in enumerate(ts):
+                row = [t] + [glifo.get(g, default_col)[i] for g in GLYPHS_CANONICAL]
+                writer.writerow(row)
+        with open(base_path + "_sigma.csv", "w", newline="") as f:
+            writer = csv.writer(f)
+            writer.writerow(["t", "x", "y", "mag", "angle"])
+            for i, t in enumerate(sigma["t"]):
+                writer.writerow([t, sigma["sigma_x"][i], sigma["sigma_y"][i], sigma["mag"][i], sigma["angle"][i]])
+    else:
+        data = {"glifogram": glifo, "sigma": sigma}
+        with open(base_path + ".json", "w") as f:
+            json.dump(data, f)

tnfr/operators.py

@@ -21,6 +21,15 @@ Nota sobre α (alpha) de RE’MESH: se toma por prioridad de
 3) DEFAULTS["REMESH_ALPHA"]
 """
 
+
+def _node_offset(G, n) -> int:
+    """Deterministic node index used for jitter seeds."""
+    mapping = G.graph.get("_node_offset_map")
+    if mapping is None or len(mapping) != G.number_of_nodes():
+        mapping = {node: idx for idx, node in enumerate(sorted(G.nodes(), key=lambda x: str(x)))}
+        G.graph["_node_offset_map"] = mapping
+    return int(mapping.get(n, 0))
+
 # -------------------------
 # Glifos (operadores locales)
 # -------------------------
@@ -55,7 +64,7 @@ def op_OZ(G, n):  # O’Z — Disonancia (aumenta ΔNFR o añade ruido)
     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)
+        rnd = random.Random(base_seed + step_idx*1000003 + _node_offset(G, 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)
@@ -124,7 +133,7 @@ def op_NAV(G, n):  # NA’V — Transición (jitter suave de ΔNFR)
         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)
+        rnd = random.Random(base_seed + step_idx*1000003 + _node_offset(G, n) % 1009)
         jitter = j * (2.0 * rnd.random() - 1.0)
     else:
         # comportamiento determinista (compatibilidad previa)
@@ -181,29 +190,31 @@ def aplicar_glifo(G, n, glifo: str, *, window: Optional[int] = None) -> None:
 # -------------------------
 
 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"])
+    """Devuelve `(alpha, source)` con precedencia explícita."""
+    if bool(G.graph.get("REMESH_ALPHA_HARD", DEFAULTS.get("REMESH_ALPHA_HARD", False))):
+        val = float(G.graph.get("REMESH_ALPHA", DEFAULTS["REMESH_ALPHA"]))
+        return val, "REMESH_ALPHA"
+    gf = G.graph.get("GLYPH_FACTORS", DEFAULTS.get("GLYPH_FACTORS", {}))
     if "REMESH_alpha" in gf:
-        return float(gf["REMESH_alpha"]), "GLYPH_FACTORS"
+        return float(gf["REMESH_alpha"]), "GLYPH_FACTORS.REMESH_alpha"
     if "REMESH_ALPHA" in G.graph:
-        return float(G.graph["REMESH_ALPHA"]), "G.graph"
-    return float(DEFAULTS["REMESH_ALPHA"]), "DEFAULTS"
+        return float(G.graph["REMESH_ALPHA"]), "REMESH_ALPHA"
+    return float(DEFAULTS["REMESH_ALPHA"]), "DEFAULTS.REMESH_ALPHA"
 
 
 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"]))
+    """RE’MESH a escala de red usando _epi_hist con memoria multi-escala."""
+    tau_g = int(G.graph.get("REMESH_TAU_GLOBAL", G.graph.get("REMESH_TAU", DEFAULTS["REMESH_TAU_GLOBAL"])))
+    tau_l = int(G.graph.get("REMESH_TAU_LOCAL", G.graph.get("REMESH_TAU", DEFAULTS["REMESH_TAU_LOCAL"])))
+    tau_req = max(tau_g, tau_l)
     alpha, alpha_src = _remesh_alpha_info(G)
+    G.graph["_REMESH_ALPHA_SRC"] = alpha_src
     hist = G.graph.get("_epi_hist", deque())
-    if len(hist) < tau + 1:
+    if len(hist) < tau_req + 1:
         return
 
-    past = hist[-(tau + 1)]
+    past_g = hist[-(tau_g + 1)]
+    past_l = hist[-(tau_l + 1)]
 
     # --- Topología + snapshot EPI (ANTES) ---
     try:
@@ -228,8 +239,11 @@ def aplicar_remesh_red(G) -> None:
     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)
+        epi_old_l = float(past_l.get(n, epi_now))
+        epi_old_g = float(past_g.get(n, epi_now))
+        mixed = (1 - alpha) * epi_now + alpha * epi_old_l
+        mixed = (1 - alpha) * mixed + alpha * epi_old_g
+        _set_attr(nd, ALIAS_EPI, mixed)
 
     # --- Snapshot EPI (DESPUÉS) ---
     epi_mean_after = list_mean(_get_attr(G.nodes[n], ALIAS_EPI, 0.0) for n in G.nodes())
@@ -242,7 +256,8 @@ def aplicar_remesh_red(G) -> None:
     meta = {
         "alpha": alpha,
         "alpha_source": alpha_src,
-        "tau": tau,
+        "tau_global": tau_g,
+        "tau_local": tau_l,
         "step": step_idx,
         # firmas
         "topo_hash": topo_hash,
@@ -278,6 +293,9 @@ def aplicar_remesh_si_estabilizacion_global(G, pasos_estables_consecutivos: Opti
     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"]))
+    min_sigma = float(G.graph.get("REMESH_MIN_SIGMA_MAG", DEFAULTS["REMESH_MIN_SIGMA_MAG"]))
+    min_R = float(G.graph.get("REMESH_MIN_KURAMOTO_R", DEFAULTS["REMESH_MIN_KURAMOTO_R"]))
+    min_sihi = float(G.graph.get("REMESH_MIN_SI_HI_FRAC", DEFAULTS["REMESH_MIN_SI_HI_FRAC"]))
 
     hist = G.graph.setdefault("history", {"stable_frac": []})
     sf = hist.get("stable_frac", [])
@@ -300,7 +318,22 @@ def aplicar_remesh_si_estabilizacion_global(G, pasos_estables_consecutivos: Opti
         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):
+        # magnitud de sigma (mayor mejor)
+        sig_ok = True
+        if "sense_sigma_mag" in hist and len(hist["sense_sigma_mag"]) >= w_estab:
+            win_sig = hist["sense_sigma_mag"][-w_estab:]
+            sig_ok = (sum(win_sig)/len(win_sig)) >= min_sigma
+        # orden de Kuramoto R (mayor mejor)
+        R_ok = True
+        if "kuramoto_R" in hist and len(hist["kuramoto_R"]) >= w_estab:
+            win_R = hist["kuramoto_R"][-w_estab:]
+            R_ok = (sum(win_R)/len(win_R)) >= min_R
+        # fracción de nodos con Si alto (mayor mejor)
+        sihi_ok = True
+        if "Si_hi_frac" in hist and len(hist["Si_hi_frac"]) >= w_estab:
+            win_sihi = hist["Si_hi_frac"][-w_estab:]
+            sihi_ok = (sum(win_sihi)/len(win_sihi)) >= min_sihi
+        if not (ps_ok and disr_ok and sig_ok and R_ok and sihi_ok):
             return
     # 3) Cooldown
     last = G.graph.get("_last_remesh_step", -10**9)
@@ -308,6 +341,12 @@ def aplicar_remesh_si_estabilizacion_global(G, pasos_estables_consecutivos: Opti
     cooldown = int(G.graph.get("REMESH_COOLDOWN_VENTANA", DEFAULTS["REMESH_COOLDOWN_VENTANA"]))
     if step_idx - last < cooldown:
         return
+    t_now = float(G.graph.get("_t", 0.0))
+    last_ts = float(G.graph.get("_last_remesh_ts", -1e12))
+    cooldown_ts = float(G.graph.get("REMESH_COOLDOWN_TS", DEFAULTS.get("REMESH_COOLDOWN_TS", 0.0)))
+    if cooldown_ts > 0 and (t_now - last_ts) < cooldown_ts:
+        return
     # 4) Aplicar y registrar
     aplicar_remesh_red(G)
     G.graph["_last_remesh_step"] = step_idx
+    G.graph["_last_remesh_ts"] = t_now

tnfr/presets.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from .program import seq, block, wait
+from .program import seq, block, wait, ejemplo_canonico_basico
 
 
 _PRESETS = {
@@ -15,6 +15,10 @@ _PRESETS = {
         "R’A",
         "SH’A",
     ),
+    "ejemplo_canonico": ejemplo_canonico_basico(),
+    # Topologías fractales: expansión/contracción modular
+    "fractal_expand": seq(block("T’HOL", "VA’L", "U’M", repeat=2, close="NU’L"), "R’A"),
+    "fractal_contract": seq(block("T’HOL", "NU’L", "U’M", repeat=2, close="SH’A"), "R’A"),
 }
 
 

tnfr/program.py

@@ -166,3 +166,11 @@ def target(nodes: Optional[Iterable[Node]] = None) -> TARGET:
 
 def wait(steps: int = 1) -> WAIT:
     return WAIT(steps=max(1, int(steps)))
+
+
+def ejemplo_canonico_basico() -> List[Token]:
+    """Secuencia canónica de referencia.
+
+    SH’A → A’L → R’A → Z’HIR → NU’L → T’HOL
+    """
+    return seq("SH’A", "A’L", "R’A", "Z’HIR", "NU’L", "T’HOL")

tnfr/scenarios.py

@@ -17,12 +17,18 @@ def build_graph(n: int = 24, topology: str = "ring", seed: int | None = 1):
     else:
         G = nx.path_graph(n)
 
+    # Valores canónicos para inicialización
+    inject_defaults(G, DEFAULTS)
+    vf_min = float(G.graph.get("VF_MIN", DEFAULTS["VF_MIN"]))
+    vf_max = float(G.graph.get("VF_MAX", DEFAULTS["VF_MAX"]))
+    th_min = float(G.graph.get("INIT_THETA_MIN", DEFAULTS.get("INIT_THETA_MIN", -3.1416)))
+    th_max = float(G.graph.get("INIT_THETA_MAX", DEFAULTS.get("INIT_THETA_MAX", 3.1416)))
+
     for i in G.nodes():
         nd = G.nodes[i]
         nd.setdefault("EPI", rng.uniform(0.1, 0.3))
-        nd.setdefault("νf", rng.uniform(0.8, 1.2))
-        nd.setdefault("θ", rng.uniform(-3.1416, 3.1416))
+        nd.setdefault("νf", rng.uniform(vf_min, vf_max))
+        nd.setdefault("θ", rng.uniform(th_min, th_max))
         nd.setdefault("Si", rng.uniform(0.4, 0.7))
 
-    inject_defaults(G, DEFAULTS)
     return G

tnfr/sense.py

@@ -4,7 +4,7 @@ import math
 from collections import Counter
 
 from .constants import DEFAULTS, ALIAS_SI, ALIAS_EPI
-from .helpers import _get_attr, clamp01, register_callback
+from .helpers import _get_attr, clamp01, register_callback, ensure_history, last_glifo
 
 # -------------------------
 # Canon: orden circular de glifos y ángulos
@@ -60,23 +60,14 @@ def _weight(G, n, mode: str) -> float:
     return 1.0
 
 
-def _last_glifo(nd: Dict[str, Any]) -> str | None:
-    hist = nd.get("hist_glifos")
-    if not hist:
-        return None
-    try:
-        return list(hist)[-1]
-    except Exception:
-        return None
-
-
+    
 # -------------------------
 # σ por nodo y σ global
 # -------------------------
 
 def sigma_vector_node(G, n, weight_mode: str | None = None) -> Dict[str, float] | None:
     nd = G.nodes[n]
-    g = _last_glifo(nd)
+    g = last_glifo(nd)
     if g is None:
         return None
     w = _weight(G, n, weight_mode or G.graph.get("SIGMA", DEFAULTS["SIGMA"]).get("weight", "Si"))
@@ -120,17 +111,11 @@ def sigma_vector_global(G, weight_mode: str | None = None) -> Dict[str, float]:
 # Historia / series
 # -------------------------
 
-def _ensure_history(G):
-    if "history" not in G.graph:
-        G.graph["history"] = {}
-    return G.graph["history"]
-
-
 def push_sigma_snapshot(G, t: float | None = None) -> None:
     cfg = G.graph.get("SIGMA", DEFAULTS["SIGMA"])
     if not cfg.get("enabled", True):
         return
-    hist = _ensure_history(G)
+    hist = ensure_history(G)
     key = cfg.get("history_key", "sigma_global")
 
     # Global
@@ -153,7 +138,7 @@ def push_sigma_snapshot(G, t: float | None = None) -> None:
     # Conteo de glifos por paso (útil para rosa glífica)
     counts = Counter()
     for n in G.nodes():
-        g = _last_glifo(G.nodes[n])
+        g = last_glifo(G.nodes[n])
         if g:
             counts[g] += 1
     hist.setdefault("sigma_counts", []).append({"t": sv["t"], **counts})
@@ -163,7 +148,7 @@ def push_sigma_snapshot(G, t: float | None = None) -> None:
         per = hist.setdefault("sigma_per_node", {})
         for n in G.nodes():
             nd = G.nodes[n]
-            g = _last_glifo(nd)
+            g = last_glifo(nd)
             if not g:
                 continue
             a = glyph_angle(g)

tnfr/trace.py

@@ -3,7 +3,7 @@ from typing import Any, Dict, List, Optional
 from collections import Counter
 
 from .constants import DEFAULTS
-from .helpers import register_callback
+from .helpers import register_callback, ensure_history, last_glifo
 
 try:
     from .gamma import kuramoto_R_psi
@@ -22,7 +22,7 @@ except Exception:  # pragma: no cover
 # -------------------------
 DEFAULTS.setdefault("TRACE", {
     "enabled": True,
-    "capture": ["gamma", "grammar", "selector", "dnfr_mix", "callbacks", "thol_state", "sigma", "kuramoto", "glifo_counts"],
+    "capture": ["gamma", "grammar", "selector", "dnfr_weights", "si_weights", "callbacks", "thol_state", "sigma", "kuramoto", "glifo_counts"],
     "history_key": "trace_meta",
 })
 
@@ -30,22 +30,6 @@ DEFAULTS.setdefault("TRACE", {
 # Helpers
 # -------------------------
 
-def _ensure_history(G):
-    if "history" not in G.graph:
-        G.graph["history"] = {}
-    return G.graph["history"]
-
-
-def _last_glifo(nd: Dict[str, Any]) -> str | None:
-    h = nd.get("hist_glifos")
-    if not h:
-        return None
-    try:
-        return list(h)[-1]
-    except Exception:
-        return None
-
-
 # -------------------------
 # Snapshots
 # -------------------------
@@ -55,7 +39,7 @@ def _trace_before(G, *args, **kwargs):
         return
     cfg = G.graph.get("TRACE", DEFAULTS["TRACE"])
     capture: List[str] = list(cfg.get("capture", []))
-    hist = _ensure_history(G)
+    hist = ensure_history(G)
     key = cfg.get("history_key", "trace_meta")
 
     meta: Dict[str, Any] = {"t": float(G.graph.get("_t", 0.0)), "phase": "before"}
@@ -70,10 +54,14 @@ def _trace_before(G, *args, **kwargs):
         sel = G.graph.get("glyph_selector")
         meta["selector"] = getattr(sel, "__name__", str(sel)) if sel else None
 
-    if "dnfr_mix" in capture:
-        # tratar de capturar varias convenciones posibles
-        mix = G.graph.get("DNFR_MIX") or G.graph.get("DELTA_NFR_MIX") or G.graph.get("NFR_MIX")
-        meta["dnfr_mix"] = mix if isinstance(mix, dict) else {"value": mix}
+    if "dnfr_weights" in capture:
+        mix = G.graph.get("DNFR_WEIGHTS")
+        if isinstance(mix, dict):
+            meta["dnfr_weights"] = dict(mix)
+
+    if "si_weights" in capture:
+        meta["si_weights"] = dict(G.graph.get("_Si_weights", {}))
+        meta["si_sensitivity"] = dict(G.graph.get("_Si_sensitivity", {}))
 
     if "callbacks" in capture:
         # si el motor guarda los callbacks, exponer nombres por fase
@@ -99,7 +87,7 @@ def _trace_after(G, *args, **kwargs):
         return
     cfg = G.graph.get("TRACE", DEFAULTS["TRACE"])
     capture: List[str] = list(cfg.get("capture", []))
-    hist = _ensure_history(G)
+    hist = ensure_history(G)
     key = cfg.get("history_key", "trace_meta")
 
     meta: Dict[str, Any] = {"t": float(G.graph.get("_t", 0.0)), "phase": "after"}
@@ -115,7 +103,7 @@ def _trace_after(G, *args, **kwargs):
     if "glifo_counts" in capture:
         cnt = Counter()
         for n in G.nodes():
-            g = _last_glifo(G.nodes[n])
+            g = last_glifo(G.nodes[n])
             if g:
                 cnt[g] += 1
         meta["glifos"] = dict(cnt)
@@ -134,7 +122,8 @@ def register_trace(G) -> None:
       - gamma: especificación activa de Γi(R)
       - grammar: configuración de gramática canónica
       - selector: nombre del selector glífico
-      - dnfr_mix: mezcla (si el motor la expone en G.graph)
+      - dnfr_weights: mezcla ΔNFR declarada en el motor
+      - si_weights: pesos α/β/γ y sensibilidad de Si
       - callbacks: callbacks registrados por fase (si están en G.graph['_callbacks'])
       - thol_open_nodes: cuántos nodos tienen bloque T’HOL abierto
       - kuramoto: (R, ψ) de la red