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

tnfr/__init__.py

@@ -1,57 +1,59 @@
-
-from __future__ import annotations
-"""
-TNFR — Teoría de la Naturaleza Fractal Resonante
-API pública del paquete.
-
-Ecuación nodal:
-    ∂EPI/∂t = νf · ΔNFR(t)
-"""
-
-__version__ = "4.0.0"
-
-# Re-exports de la API pública
-from .dynamics import step, run, set_delta_nfr_hook
-from .ontosim import preparar_red
-from .observers import attach_standard_observer, coherencia_global, orden_kuramoto
-from .gamma import GAMMA_REGISTRY, eval_gamma, kuramoto_R_psi
-from .grammar import enforce_canonical_grammar, on_applied_glifo
-from .sense import (
-    GLYPHS_CANONICAL, glyph_angle, glyph_unit,
-    sigma_vector_node, sigma_vector_global,
-    push_sigma_snapshot, sigma_series, sigma_rose,
-    register_sigma_callback,
-)
-from .metrics import (
-    register_metrics_callbacks,
-    Tg_global, Tg_by_node,
-    latency_series, glifogram_series,
-    glyph_top, glyph_dwell_stats,
-)
-from .trace import register_trace
-from .program import play, seq, block, target, wait, THOL, TARGET, WAIT
-from .cli import main as cli_main
-from .scenarios import build_graph
-from .presets import get_preset
-from .types import NodeState
-
-__all__ = [
-    "preparar_red",
-    "step", "run", "set_delta_nfr_hook",
-    "attach_standard_observer", "coherencia_global", "orden_kuramoto",
-    "GAMMA_REGISTRY", "eval_gamma", "kuramoto_R_psi",
-    "enforce_canonical_grammar", "on_applied_glifo",
-    "GLYPHS_CANONICAL", "glyph_angle", "glyph_unit",
-    "sigma_vector_node", "sigma_vector_global",
-    "push_sigma_snapshot", "sigma_series", "sigma_rose",
-    "register_sigma_callback",
-    "register_metrics_callbacks",
-    "register_trace",
-    "Tg_global", "Tg_by_node",
-    "latency_series", "glifogram_series",
-    "glyph_top", "glyph_dwell_stats",
-    "play", "seq", "block", "target", "wait", "THOL", "TARGET", "WAIT",
-    "__version__",
-]
-
-__all__ += ["cli_main", "build_graph", "get_preset", "NodeState"]
+
+from __future__ import annotations
+"""
+TNFR — Teoría de la Naturaleza Fractal Resonante
+API pública del paquete.
+
+Ecuación nodal:
+    ∂EPI/∂t = νf · ΔNFR(t)
+"""
+
+__version__ = "4.1.0"
+
+# Re-exports de la API pública
+from .dynamics import step, run, set_delta_nfr_hook
+from .ontosim import preparar_red
+from .observers import attach_standard_observer, coherencia_global, orden_kuramoto
+from .gamma import GAMMA_REGISTRY, eval_gamma, kuramoto_R_psi
+from .grammar import enforce_canonical_grammar, on_applied_glifo
+from .sense import (
+    GLYPHS_CANONICAL, glyph_angle, glyph_unit,
+    sigma_vector_node, sigma_vector_global,
+    push_sigma_snapshot, sigma_series, sigma_rose,
+    register_sigma_callback,
+)
+from .metrics import (
+    register_metrics_callbacks,
+    Tg_global, Tg_by_node,
+    latency_series, glifogram_series,
+    glyph_top, glyph_dwell_stats,
+)
+from .trace import register_trace
+from .program import play, seq, block, target, wait, THOL, TARGET, WAIT, ejemplo_canonico_basico
+from .cli import main as cli_main
+from .scenarios import build_graph
+from .presets import get_preset
+from .types import NodeState
+
+
+__all__ = [
+    "preparar_red",
+    "step", "run", "set_delta_nfr_hook",
+
+    "attach_standard_observer", "coherencia_global", "orden_kuramoto",
+    "GAMMA_REGISTRY", "eval_gamma", "kuramoto_R_psi",
+    "enforce_canonical_grammar", "on_applied_glifo",
+    "GLYPHS_CANONICAL", "glyph_angle", "glyph_unit",
+    "sigma_vector_node", "sigma_vector_global",
+    "push_sigma_snapshot", "sigma_series", "sigma_rose",
+    "register_sigma_callback",
+    "register_metrics_callbacks",
+    "register_trace",
+    "Tg_global", "Tg_by_node",
+    "latency_series", "glifogram_series",
+    "glyph_top", "glyph_dwell_stats",
+    "play", "seq", "block", "target", "wait", "THOL", "TARGET", "WAIT",
+    "cli_main", "build_graph", "get_preset", "NodeState",
+    "ejemplo_canonico_basico",
+    "__version__",
+]

tnfr/cli.py

@@ -21,7 +21,8 @@ from .metrics import (
 )
 from .trace import register_trace
 from .program import play, seq, block, wait, target
-from .dynamics import step, _update_history
+from .dynamics import step, _update_history, default_glyph_selector, parametric_glyph_selector
+from .gamma import GAMMA_REGISTRY
 from .scenarios import build_graph
 from .presets import get_preset
 
@@ -72,6 +73,9 @@ def _attach_callbacks(G: nx.Graph) -> None:
 def cmd_run(args: argparse.Namespace) -> int:
     G = build_graph(n=args.nodes, topology=args.topology, seed=args.seed)
     _attach_callbacks(G)
+    G.graph.setdefault("GRAMMAR_CANON", DEFAULTS["GRAMMAR_CANON"]).update({"enabled": bool(args.grammar_canon)})
+    G.graph["glyph_selector"] = default_glyph_selector if args.selector == "basic" else parametric_glyph_selector
+    G.graph["GAMMA"] = {"type": args.gamma}
 
     if args.preset:
         program = get_preset(args.preset)
@@ -96,6 +100,9 @@ def cmd_run(args: argparse.Namespace) -> int:
 def cmd_sequence(args: argparse.Namespace) -> int:
     G = build_graph(n=args.nodes, topology=args.topology, seed=args.seed)
     _attach_callbacks(G)
+    G.graph.setdefault("GRAMMAR_CANON", DEFAULTS["GRAMMAR_CANON"]).update({"enabled": bool(args.grammar_canon)})
+    G.graph["glyph_selector"] = default_glyph_selector if args.selector == "basic" else parametric_glyph_selector
+    G.graph["GAMMA"] = {"type": args.gamma}
 
     if args.preset:
         program = get_preset(args.preset)
@@ -114,6 +121,9 @@ def cmd_sequence(args: argparse.Namespace) -> int:
 def cmd_metrics(args: argparse.Namespace) -> int:
     G = build_graph(n=args.nodes, topology=args.topology, seed=args.seed)
     _attach_callbacks(G)
+    G.graph.setdefault("GRAMMAR_CANON", DEFAULTS["GRAMMAR_CANON"]).update({"enabled": bool(args.grammar_canon)})
+    G.graph["glyph_selector"] = default_glyph_selector if args.selector == "basic" else parametric_glyph_selector
+    G.graph["GAMMA"] = {"type": args.gamma}
     for _ in range(int(args.steps or 200)):
         step(G)
 
@@ -147,6 +157,9 @@ def main(argv: Optional[List[str]] = None) -> int:
     p_run.add_argument("--preset", type=str, default=None)
     p_run.add_argument("--save-history", dest="save_history", type=str, default=None)
     p_run.add_argument("--summary", action="store_true")
+    p_run.add_argument("--no-canon", dest="grammar_canon", action="store_false", default=True, help="Desactiva gramática canónica")
+    p_run.add_argument("--selector", choices=["basic", "param"], default="basic")
+    p_run.add_argument("--gamma", choices=list(GAMMA_REGISTRY.keys()), default="none")
     p_run.set_defaults(func=cmd_run)
 
     p_seq = sub.add_parser("sequence", help="Ejecutar una secuencia (preset o YAML/JSON)")
@@ -163,6 +176,9 @@ def main(argv: Optional[List[str]] = None) -> int:
     p_met.add_argument("--topology", choices=["ring", "complete", "erdos"], default="ring")
     p_met.add_argument("--steps", type=int, default=300)
     p_met.add_argument("--seed", type=int, default=1)
+    p_met.add_argument("--no-canon", dest="grammar_canon", action="store_false", default=True, help="Desactiva gramática canónica")
+    p_met.add_argument("--selector", choices=["basic", "param"], default="basic")
+    p_met.add_argument("--gamma", choices=list(GAMMA_REGISTRY.keys()), default="none")
     p_met.add_argument("--save", type=str, default=None)
     p_met.set_defaults(func=cmd_metrics)
 

tnfr/constants.py

@@ -72,8 +72,9 @@ DEFAULTS: Dict[str, Any] = {
     # Criterios de estabilidad (para activar RE’MESH de red)
     "EPS_DNFR_STABLE": 1e-3,
     "EPS_DEPI_STABLE": 1e-3,
-    "FRACTION_STABLE_REMESH": 0.80,   # fracción de nodos estables requerida
-    "REMESH_COOLDOWN_VENTANA": 20,    # pasos mínimos entre RE’MESH
+    "FRACTION_STABLE_REMESH": 0.80,   # fracción de nodos estables requerida
+    "REMESH_COOLDOWN_VENTANA": 20,    # pasos mínimos entre RE’MESH
+    "REMESH_COOLDOWN_TS": 0.0,        # cooldown adicional por tiempo simulado
     # Gating adicional basado en observadores (conmutador + ventana)
     "REMESH_REQUIRE_STABILITY": False, # si True, exige ventana de estabilidad multi-métrica
     "REMESH_STABILITY_WINDOW": 25,     # tamaño de ventana para evaluar estabilidad
@@ -82,8 +83,9 @@ DEFAULTS: Dict[str, Any] = {
     "REMESH_LOG_EVENTS": True,         # guarda eventos y metadatos del RE’MESH
 
     # RE’MESH: memoria τ y mezcla α
-    "REMESH_TAU": 8,                  # pasos hacia atrás
-    "REMESH_ALPHA": 0.5,              # mezcla con pasado
+    "REMESH_TAU": 8,                  # pasos hacia atrás
+    "REMESH_ALPHA": 0.5,              # mezcla con pasado
+    "REMESH_ALPHA_HARD": False,       # si True ignora GLYPH_FACTORS['REMESH_alpha']
 
     # Histéresis glífica
     "GLYPH_HYSTERESIS_WINDOW": 7,
@@ -92,13 +94,13 @@ DEFAULTS: Dict[str, Any] = {
     "GLYPH_SELECTOR_MARGIN": 0.05,
 
     # Ventana para estimar la carga glífica en history/plots
-    "GLYPH_LOAD_WINDOW": 50,
+    "GLYPH_LOAD_WINDOW": 50,
 
     # Tamaño de ventana para coherencia promedio W̄
     "WBAR_WINDOW": 25,  
 
     # Factores suaves por glifo (operadores)
-    "GLYPH_FACTORS": {
+    "GLYPH_FACTORS": {
         "AL_boost": 0.05,   # A’L — pequeña emisión
         "EN_mix": 0.25,     # E’N — mezcla con vecindad
         "IL_dnfr_factor": 0.7,  # I’L — reduce ΔNFR
@@ -107,7 +109,7 @@ DEFAULTS: Dict[str, Any] = {
         "RA_epi_diff": 0.15,    # R’A — difusión EPI
         "SHA_vf_factor": 0.85,  # SH’A — baja νf
         "VAL_scale": 1.15,      # VA’L — expande EPI
-        "NUL_scale": 0.85,      # NU’L — contrae EPI
+        "NUL_scale": 0.85,      # NU’L — contrae EPI
         "THOL_accel": 0.10,     # T’HOL — acelera (seg. deriv.) si hay umbral
         "ZHIR_theta_shift": 1.57079632679,  # Z’HIR — desplazamiento ~π/2
         "NAV_jitter": 0.05,     # NA’V — pequeña inestabilidad creativa
@@ -154,6 +156,7 @@ DEFAULTS: Dict[str, Any] = {
         "R0": 0.0,
     },
     "CALLBACKS_STRICT": False,  # si True, un error en callback detiene; si False, se loguea y continúa
+    "VALIDATORS_STRICT": False, # si True, alerta si se clampa fuera de rango
 }
 
 # Gramática glífica canónica

tnfr/dynamics.py

@@ -187,7 +187,7 @@ def integrar_epi_euler(G, dt: float | None = None) -> None:
     update_epi_via_nodal_equation(G, dt=dt)
 
 
-def aplicar_clamps_canonicos(nd: Dict[str, Any], G=None) -> None:
+def aplicar_clamps_canonicos(nd: Dict[str, Any], G=None, node=None) -> None:
     eps_min = float((G.graph.get("EPI_MIN") if G is not None else DEFAULTS["EPI_MIN"]))
     eps_max = float((G.graph.get("EPI_MAX") if G is not None else DEFAULTS["EPI_MAX"]))
     vf_min = float((G.graph.get("VF_MIN") if G is not None else DEFAULTS["VF_MIN"]))
@@ -197,6 +197,14 @@ def aplicar_clamps_canonicos(nd: Dict[str, Any], G=None) -> None:
     vf = _get_attr(nd, ALIAS_VF, 0.0)
     th = _get_attr(nd, ALIAS_THETA, 0.0)
 
+    strict = bool((G.graph.get("VALIDATORS_STRICT") if G is not None else DEFAULTS.get("VALIDATORS_STRICT", False)))
+    if strict and G is not None:
+        hist = G.graph.setdefault("history", {}).setdefault("clamp_alerts", [])
+        if epi < eps_min or epi > eps_max:
+            hist.append({"node": node, "attr": "EPI", "value": float(epi)})
+        if vf < vf_min or vf > vf_max:
+            hist.append({"node": node, "attr": "VF", "value": float(vf)})
+
     _set_attr(nd, ALIAS_EPI, clamp(epi, eps_min, eps_max))
     _set_attr(nd, ALIAS_VF, clamp(vf, vf_min, vf_max))
     if (G.graph.get("THETA_WRAP") if G is not None else DEFAULTS["THETA_WRAP"]):
@@ -212,6 +220,10 @@ def coordinar_fase_global_vecinal(G, fuerza_global: float | None = None, fuerza_
     """
     g = G.graph
     defaults = DEFAULTS
+    hist = g.setdefault("history", {})
+    hist_state = hist.setdefault("phase_state", [])
+    hist_R = hist.setdefault("phase_R", [])
+    hist_disr = hist.setdefault("phase_disr", [])
     # 0) Si hay fuerzas explícitas, usar y salir del modo adaptativo
     if (fuerza_global is not None) or (fuerza_vecinal is not None):
         kG = float(
@@ -273,20 +285,15 @@ def coordinar_fase_global_vecinal(G, fuerza_global: float | None = None, fuerza_
             kL = _step(kL, kL_t, kL_min, kL_max)
 
             # 5) Persistir en G.graph y log de serie
-            g["PHASE_K_GLOBAL"] = kG
-            g["PHASE_K_LOCAL"] = kL
-            hist = g.setdefault("history", {})
-            hist_kG = hist.setdefault("phase_kG", [])
-            hist_kL = hist.setdefault("phase_kL", [])
-            hist_state = hist.setdefault("phase_state", [])
-            hist_R = hist.setdefault("phase_R", [])
-            hist_disr = hist.setdefault("phase_disr", [])
-            hist_kG.append(float(kG))
-            hist_kL.append(float(kL))
             hist_state.append(state)
             hist_R.append(float(R))
             hist_disr.append(float(disr))
 
+    g["PHASE_K_GLOBAL"] = kG
+    g["PHASE_K_LOCAL"] = kL
+    hist.setdefault("phase_kG", []).append(float(kG))
+    hist.setdefault("phase_kL", []).append(float(kL))
+
     # 6) Fase GLOBAL (centroide) para empuje
     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())
@@ -345,6 +352,21 @@ def _norms_para_selector(G) -> dict:
     G.graph["_sel_norms"] = norms
     return norms
 
+
+def _soft_grammar_prefilter(G, n, cand, dnfr, accel):
+    """Gramática suave: evita repeticiones antes de la canónica."""
+    gram = G.graph.get("GRAMMAR", DEFAULTS.get("GRAMMAR", {}))
+    gwin = int(gram.get("window", 3))
+    avoid = set(gram.get("avoid_repeats", []))
+    force_dn = float(gram.get("force_dnfr", 0.60))
+    force_ac = float(gram.get("force_accel", 0.60))
+    fallbacks = gram.get("fallbacks", {})
+    nd = G.nodes[n]
+    if cand in avoid and reciente_glifo(nd, cand, gwin):
+        if not (dnfr >= force_dn or accel >= force_ac):
+            cand = fallbacks.get(cand, cand)
+    return cand
+
 def parametric_glyph_selector(G, n) -> str:
     """Multiobjetivo: combina Si, |ΔNFR|_norm y |accel|_norm + histéresis.
     Reglas base:
@@ -412,22 +434,9 @@ def parametric_glyph_selector(G, n) -> str:
         elif score <= 0.33 and cand in ("NA’V","R’A","I’L"):
             cand = "O’Z" if dnfr >= dnfr_lo else "Z’HIR"
     except NameError:
-        # por si 'score' no se definió (robustez), no forzamos nada
         pass
 
-    # --- Gramática glífica suave: evita repeticiones cercanas salvo que el campo lo pida ---
-    gram = G.graph.get("GRAMMAR", DEFAULTS.get("GRAMMAR", {}))
-    gwin = int(gram.get("window", 3))
-    avoid = set(gram.get("avoid_repeats", []))
-    force_dn = float(gram.get("force_dnfr", 0.60))
-    force_ac = float(gram.get("force_accel", 0.60))
-    fallbacks = gram.get("fallbacks", {})
-
-    if cand in avoid and reciente_glifo(nd, cand, gwin):
-        # Solo permitimos repetir si el campo "insiste": dnfr o accel altos (ya normalizados)
-        if not (dnfr >= force_dn or accel >= force_ac):
-            cand = fallbacks.get(cand, "R’A")
-
+    cand = _soft_grammar_prefilter(G, n, cand, dnfr, accel)
     return cand
 
 # -------------------------
@@ -470,7 +479,7 @@ def step(G, *, dt: float | None = None, use_Si: bool = True, apply_glyphs: bool
 
     # 5) Clamps
     for n in G.nodes():
-        aplicar_clamps_canonicos(G.nodes[n], G)
+        aplicar_clamps_canonicos(G.nodes[n], G, n)
 
     # 6) Coordinación de fase
     coordinar_fase_global_vecinal(G, None, None)

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

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

@@ -186,7 +186,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 +199,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/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,13 +190,15 @@ 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"]"""
+    """Devuelve (alpha, source) con precedencia explícita."""
+    hard = bool(G.graph.get("REMESH_ALPHA_HARD", DEFAULTS.get("REMESH_ALPHA_HARD", False)))
     gf = G.graph.get("GLYPH_FACTORS", DEFAULTS["GLYPH_FACTORS"])
-    if "REMESH_alpha" in gf:
+    if not hard and "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"
+    if "REMESH_alpha" in gf:
+        return float(gf["REMESH_alpha"]), "GLYPH_FACTORS"
     return float(DEFAULTS["REMESH_ALPHA"]), "DEFAULTS"
 
 
@@ -308,6 +319,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,7 @@ _PRESETS = {
         "R’A",
         "SH’A",
     ),
+    "ejemplo_canonico": ejemplo_canonico_basico(),
 }
 
 

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/trace.py

@@ -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",
 })
 
@@ -70,10 +70,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
@@ -134,7 +138,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

{tnfr-4.0.0.dist-info → tnfr-4.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tnfr
-Version: 4.0.0
+Version: 4.1.0
 Summary: TNFR canónica: dinámica glífica modular sobre redes.
 Author: fmg
 License: MIT
@@ -59,6 +59,8 @@ Dynamic: license-file
 
 * **Network re-mesh.** Mixes the current state with a past one (memory `τ`) to stabilize the network, with clear precedence for `α` and conditions based on recent stability and synchrony history.
 
+* **Γ(R) coupling.** Optional network term added to the nodal equation, parameterized by global phase order `R` with gain `β` and threshold `R0` (see `DEFAULTS["GAMMA"]`).
+
 * **Callbacks & observers.** The `Γ(R)` system lets you hook functions before/after each step and after re-mesh, enabling monitoring or external intervention.
 
 ---

tnfr-4.1.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+tnfr/__init__.py,sha256=93fkcY9lteZyKkZuWJAB-hvDEE2q0ZYgk16qCBXe50A,1988
+tnfr/cli.py,sha256=PVU95Iik_3bn-4UrLr8H7HHGme1X0qYnTuVv_AOp9FA,7484
+tnfr/constants.py,sha256=EPFW7howB2IsyeGRc8hyzO3s6sgRkM78lWB7S3BJXq4,9147
+tnfr/dynamics.py,sha256=SIf6cTj6_Wd6DRKJRYjE-iBuaxfDRpHu-j14wzlB-J0,25598
+tnfr/gamma.py,sha256=Ccsr2yKA7f8VlVqKgckQpGAEISlBw8i3FBeNPxfS-AQ,3048
+tnfr/grammar.py,sha256=vz5F0P3IfvA6HassRcoD327hBP5vCUw-xPSTsPmqwhQ,5363
+tnfr/helpers.py,sha256=CPEBkmFY6S4DKBf91EqW5vW_jTokOzg3HojCx28KxTU,7327
+tnfr/main.py,sha256=XqjI1YEdF-OqRzTMa5dYIxCig4qyAR-l1FPcyxpC8WY,1926
+tnfr/metrics.py,sha256=XusywHo1-GgLqYy1Jz43Xc4zRsggrn_DwoaFWfAy82M,6640
+tnfr/observers.py,sha256=PTw3hxk7KD-Yx_CvCIU09icuhyYD6uNU6SvF80UvP-Y,5354
+tnfr/ontosim.py,sha256=9GfEtiLIdJOPJUTufcq_MssAA9J8AfChHU6HKb3DIJY,5628
+tnfr/operators.py,sha256=QYsGf9R3lr8WdR0kanLqGYqZ-Lw-RWzjqKKTczgtyEw,13741
+tnfr/presets.py,sha256=rN6kDnI59DfYCL0YuYQr0yEu8jZaCFezGBnIWn6HFn8,737
+tnfr/program.py,sha256=eim7D8zsbbkGDWbODag-0VKG44jEYioX4Sl6KRwgVtw,6038
+tnfr/scenarios.py,sha256=FgsXzA6ENRkalENnG5ZuBNFguEGaKZTM6y0quW5fJI4,808
+tnfr/sense.py,sha256=1yVlphcs4o_uOQ51MDqW9dphydMiDNKv1Z1EdgbJgpU,6778
+tnfr/trace.py,sha256=bY0GU5I5yvHKSDOUQ0m5ICaXScYHzCM5xOWqTO68VO0,5026
+tnfr/types.py,sha256=xyFHp0PptEqPNUekAFH6DcAnyMx4bCQutMyFUXMd2sA,457
+tnfr-4.1.0.dist-info/licenses/LICENSE.md,sha256=SRvvhXLrKtseuK6DARbuJffuXOXqAyk3wvF2n0t1SWA,1109
+tnfr-4.1.0.dist-info/METADATA,sha256=cuR46do-ZJA5_OiZy4MNCwwbsEAi6DYD0HcRVTTYIz8,6075
+tnfr-4.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+tnfr-4.1.0.dist-info/entry_points.txt,sha256=j4-QRHqeT2WnchHe_mvK7npGTLjlyfLpvRONFe9Z4MU,39
+tnfr-4.1.0.dist-info/top_level.txt,sha256=Q2HJnvc5Rt2VHwVvyBTnNPT4SfmJWnCj7XUxxEvQa7c,5
+tnfr-4.1.0.dist-info/RECORD,,

tnfr-4.0.0.dist-info/RECORD

@@ -1,24 +0,0 @@
-tnfr/__init__.py,sha256=nN8P2Xm26kvJvqDhmRITnimew3SgBgw4fSUHPOAiYts,1880
-tnfr/cli.py,sha256=fdzmIOVerg6J1j6cBuu7m2-nKFG_WqiNu-e2Wg8eECQ,5980
-tnfr/constants.py,sha256=PUhps2gBXeh_rJIrCF9HpWRdi02sfRXvVp066AOgkyQ,8912
-tnfr/dynamics.py,sha256=FeFv7h4m9e8qhbU9tIRss3K6P2uz4Hfmtbldf2AhfyQ,25286
-tnfr/gamma.py,sha256=1hGqYTBYIYirgmSSSbvSuFWPVy_KGzPNH3eD7wmRUu0,2689
-tnfr/grammar.py,sha256=X50-BzTzaYkFIi-ljcgB_XXC6c2srvqzDqOKa91nsuA,5090
-tnfr/helpers.py,sha256=foJgwyC__6lQeOpPY02slFRggY3tCy1CxeFlEQcI-gY,7014
-tnfr/main.py,sha256=XqjI1YEdF-OqRzTMa5dYIxCig4qyAR-l1FPcyxpC8WY,1926
-tnfr/metrics.py,sha256=XusywHo1-GgLqYy1Jz43Xc4zRsggrn_DwoaFWfAy82M,6640
-tnfr/observers.py,sha256=PTw3hxk7KD-Yx_CvCIU09icuhyYD6uNU6SvF80UvP-Y,5354
-tnfr/ontosim.py,sha256=9GfEtiLIdJOPJUTufcq_MssAA9J8AfChHU6HKb3DIJY,5628
-tnfr/operators.py,sha256=Q2QvtK2oQUuMsq_CPdfaK9eCrhniI1NaWEfwQH08zSk,12936
-tnfr/presets.py,sha256=vaqgqz1pVU93hEOITQn-2CUGfMbN2n47A9GBFmjWRpo,661
-tnfr/program.py,sha256=qGqj74qBqXILm-Yrw73__0uIlx2gJiSF9dDHxOGTbCs,5798
-tnfr/scenarios.py,sha256=FgsXzA6ENRkalENnG5ZuBNFguEGaKZTM6y0quW5fJI4,808
-tnfr/sense.py,sha256=1yVlphcs4o_uOQ51MDqW9dphydMiDNKv1Z1EdgbJgpU,6778
-tnfr/trace.py,sha256=YtqSKJM2tCH5eLa22nObPLnYgsn4Bm6inipY0n_mwXY,4887
-tnfr/types.py,sha256=xyFHp0PptEqPNUekAFH6DcAnyMx4bCQutMyFUXMd2sA,457
-tnfr-4.0.0.dist-info/licenses/LICENSE.md,sha256=SRvvhXLrKtseuK6DARbuJffuXOXqAyk3wvF2n0t1SWA,1109
-tnfr-4.0.0.dist-info/METADATA,sha256=xzcC2N34E82NmkgYly3jpfgzLVgI9fQLNnMiXLWk2RQ,5898
-tnfr-4.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-tnfr-4.0.0.dist-info/entry_points.txt,sha256=j4-QRHqeT2WnchHe_mvK7npGTLjlyfLpvRONFe9Z4MU,39
-tnfr-4.0.0.dist-info/top_level.txt,sha256=Q2HJnvc5Rt2VHwVvyBTnNPT4SfmJWnCj7XUxxEvQa7c,5
-tnfr-4.0.0.dist-info/RECORD,,