tnfr 4.1.0__tar.gz → 4.3.0__tar.gz

{tnfr-4.1.0/src/tnfr.egg-info → tnfr-4.3.0}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: tnfr
-Version: 4.1.0
-Summary: TNFR canónica: dinámica glífica modular sobre redes.
+Version: 4.3.0
+Summary: Canonical TNFR: modular glyph-based dynamics on networks.
 Author: fmg
 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
+Keywords: TNFR,resonant fractal,resonance,glyphs,networkx,dynamics,coherence,EPI,Kuramoto
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.9
@@ -25,7 +25,13 @@ License-File: LICENSE.md
 Requires-Dist: networkx>=2.6
 Dynamic: license-file
 
-# General Project Structure
+# TNFR — Canonical Glyph-Based Dynamics
+
+Reference implementation of the Resonant Fractal Nature Theory (TNFR).
+It models glyph-driven dynamics on NetworkX graphs, providing a modular
+engine to simulate coherent reorganization processes.
+
+## General Project Structure
 
 * **Package entry point.** `__init__.py` registers modules under short names to avoid circular imports and exposes the public API: `preparar_red`, `step`, `run`, and observation utilities.
 

{tnfr-4.1.0 → tnfr-4.3.0}/README.md

@@ -1,4 +1,10 @@
-# General Project Structure
+# TNFR — Canonical Glyph-Based Dynamics
+
+Reference implementation of the Resonant Fractal Nature Theory (TNFR).
+It models glyph-driven dynamics on NetworkX graphs, providing a modular
+engine to simulate coherent reorganization processes.
+
+## General Project Structure
 
 * **Package entry point.** `__init__.py` registers modules under short names to avoid circular imports and exposes the public API: `preparar_red`, `step`, `run`, and observation utilities.
 

{tnfr-4.1.0 → tnfr-4.3.0}/pyproject.toml

@@ -1,14 +1,14 @@
 [project]
 name = "tnfr"
-version = "4.1.0"
-description = "TNFR canónica: dinámica glífica modular sobre redes."
+version = "4.3.0"
+description = "Canonical TNFR: modular glyph-based dynamics on networks."
 readme = "README.md"
 requires-python = ">=3.9"
 license = { text = "MIT" }
 authors = [{ name = "fmg" }]
 keywords = [
-  "TNFR", "fractal resonante", "resonancia", "glifos",
-  "networkx", "dinámica", "coherencia", "EPI", "Kuramoto"
+  "TNFR", "resonant fractal", "resonance", "glyphs",
+  "networkx", "dynamics", "coherence", "EPI", "Kuramoto"
 ]
 classifiers = [
   "Programming Language :: Python :: 3",

{tnfr-4.1.0 → tnfr-4.3.0}/src/tnfr/__init__.py

@@ -8,10 +8,10 @@ Ecuación nodal:
     ∂EPI/∂t = νf · ΔNFR(t)
 """
 
-__version__ = "4.1.0"
+__version__ = "4.3.0"
 
 # Re-exports de la API pública
-from .dynamics import step, run, set_delta_nfr_hook
+from .dynamics import step, run, set_delta_nfr_hook, validate_canon
 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
@@ -22,12 +22,12 @@ from .sense import (
     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 .metrics import (
+    register_metrics_callbacks,
+    Tg_global, Tg_by_node,
+    latency_series, glifogram_series,
+    glyph_top, glyph_dwell_stats, export_history,
+)
 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
@@ -37,8 +37,8 @@ from .types import NodeState
 
 
 __all__ = [
-    "preparar_red",
-    "step", "run", "set_delta_nfr_hook",
+    "preparar_red",
+    "step", "run", "set_delta_nfr_hook", "validate_canon",
 
     "attach_standard_observer", "coherencia_global", "orden_kuramoto",
     "GAMMA_REGISTRY", "eval_gamma", "kuramoto_R_psi",
@@ -51,9 +51,11 @@ __all__ = [
     "register_trace",
     "Tg_global", "Tg_by_node",
     "latency_series", "glifogram_series",
-    "glyph_top", "glyph_dwell_stats",
+    "glyph_top", "glyph_dwell_stats",
+    "export_history",
     "play", "seq", "block", "target", "wait", "THOL", "TARGET", "WAIT",
     "cli_main", "build_graph", "get_preset", "NodeState",
     "ejemplo_canonico_basico",
     "__version__",
 ]
+

{tnfr-4.1.0 → tnfr-4.3.0}/src/tnfr/cli.py

@@ -18,10 +18,11 @@ from .metrics import (
     latency_series,
     glifogram_series,
     glyph_top,
+    export_history,
 )
 from .trace import register_trace
 from .program import play, seq, block, wait, target
-from .dynamics import step, _update_history, default_glyph_selector, parametric_glyph_selector
+from .dynamics import step, _update_history, default_glyph_selector, parametric_glyph_selector, validate_canon
 from .gamma import GAMMA_REGISTRY
 from .scenarios import build_graph
 from .presets import get_preset
@@ -32,6 +33,24 @@ def _save_json(path: str, data: Any) -> None:
         json.dump(data, f, ensure_ascii=False, indent=2)
 
 
+def _str2bool(s: str) -> bool:
+    s = s.lower()
+    if s in {"true", "1", "yes", "y"}:
+        return True
+    if s in {"false", "0", "no", "n"}:
+        return False
+    raise argparse.ArgumentTypeError("expected true/false")
+
+
+def _args_to_dict(args: argparse.Namespace, prefix: str) -> Dict[str, Any]:
+    out: Dict[str, Any] = {}
+    pref = prefix.replace(".", "_")
+    for k, v in vars(args).items():
+        if k.startswith(pref) and v is not None:
+            out[k[len(pref):]] = v
+    return out
+
+
 def _load_sequence(path: str) -> List[Any]:
     with open(path, "r", encoding="utf-8") as f:
         text = f.read()
@@ -73,9 +92,20 @@ 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)})
+    validate_canon(G)
+    gcanon = dict(DEFAULTS["GRAMMAR_CANON"])
+    gcanon.update(_args_to_dict(args, prefix="grammar."))
+    if hasattr(args, "grammar_canon") and args.grammar_canon is not None:
+        gcanon["enabled"] = bool(args.grammar_canon)
+    G.graph.setdefault("GRAMMAR_CANON", {}).update(gcanon)
+    if args.glyph_hysteresis_window is not None:
+        G.graph["GLYPH_HYSTERESIS_WINDOW"] = int(args.glyph_hysteresis_window)
     G.graph["glyph_selector"] = default_glyph_selector if args.selector == "basic" else parametric_glyph_selector
-    G.graph["GAMMA"] = {"type": args.gamma}
+    G.graph["GAMMA"] = {
+        "type": args.gamma_type,
+        "beta": args.gamma_beta,
+        "R0": args.gamma_R0,
+    }
 
     if args.preset:
         program = get_preset(args.preset)
@@ -87,6 +117,8 @@ def cmd_run(args: argparse.Namespace) -> int:
 
     if args.save_history:
         _save_json(args.save_history, G.graph.get("history", {}))
+    if args.export_history_base:
+        export_history(G, args.export_history_base, fmt=args.export_format)
 
     if args.summary:
         tg = Tg_global(G, normalize=True)
@@ -100,9 +132,20 @@ 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)})
+    validate_canon(G)
+    gcanon = dict(DEFAULTS["GRAMMAR_CANON"])
+    gcanon.update(_args_to_dict(args, prefix="grammar."))
+    if hasattr(args, "grammar_canon") and args.grammar_canon is not None:
+        gcanon["enabled"] = bool(args.grammar_canon)
+    G.graph.setdefault("GRAMMAR_CANON", {}).update(gcanon)
+    if args.glyph_hysteresis_window is not None:
+        G.graph["GLYPH_HYSTERESIS_WINDOW"] = int(args.glyph_hysteresis_window)
     G.graph["glyph_selector"] = default_glyph_selector if args.selector == "basic" else parametric_glyph_selector
-    G.graph["GAMMA"] = {"type": args.gamma}
+    G.graph["GAMMA"] = {
+        "type": args.gamma_type,
+        "beta": args.gamma_beta,
+        "R0": args.gamma_R0,
+    }
 
     if args.preset:
         program = get_preset(args.preset)
@@ -115,15 +158,22 @@ def cmd_sequence(args: argparse.Namespace) -> int:
 
     if args.save_history:
         _save_json(args.save_history, G.graph.get("history", {}))
+    if args.export_history_base:
+        export_history(G, args.export_history_base, fmt=args.export_format)
     return 0
 
 
 def cmd_metrics(args: argparse.Namespace) -> int:
     G = build_graph(n=args.nodes, topology=args.topology, seed=args.seed)
     _attach_callbacks(G)
+    validate_canon(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}
+    G.graph["GAMMA"] = {
+        "type": args.gamma_type,
+        "beta": args.gamma_beta,
+        "R0": args.gamma_R0,
+    }
     for _ in range(int(args.steps or 200)):
         step(G)
 
@@ -156,10 +206,22 @@ def main(argv: Optional[List[str]] = None) -> int:
     p_run.add_argument("--seed", type=int, default=1)
     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("--export-history-base", dest="export_history_base", type=str, default=None)
+    p_run.add_argument("--export-format", dest="export_format", choices=["csv", "json"], default="json")
     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("--grammar.enabled", dest="grammar_enabled", type=_str2bool, default=None)
+    p_run.add_argument("--grammar.zhir_requires_oz_window", dest="grammar_zhir_requires_oz_window", type=int, default=None)
+    p_run.add_argument("--grammar.zhir_dnfr_min", dest="grammar_zhir_dnfr_min", type=float, default=None)
+    p_run.add_argument("--grammar.thol_min_len", dest="grammar_thol_min_len", type=int, default=None)
+    p_run.add_argument("--grammar.thol_max_len", dest="grammar_thol_max_len", type=int, default=None)
+    p_run.add_argument("--grammar.thol_close_dnfr", dest="grammar_thol_close_dnfr", type=float, default=None)
+    p_run.add_argument("--grammar.si_high", dest="grammar_si_high", type=float, default=None)
+    p_run.add_argument("--glyph.hysteresis_window", dest="glyph_hysteresis_window", type=int, default=None)
     p_run.add_argument("--selector", choices=["basic", "param"], default="basic")
-    p_run.add_argument("--gamma", choices=list(GAMMA_REGISTRY.keys()), default="none")
+    p_run.add_argument("--gamma-type", choices=list(GAMMA_REGISTRY.keys()), default="none")
+    p_run.add_argument("--gamma-beta", type=float, default=0.0)
+    p_run.add_argument("--gamma-R0", type=float, default=0.0)
     p_run.set_defaults(func=cmd_run)
 
     p_seq = sub.add_parser("sequence", help="Ejecutar una secuencia (preset o YAML/JSON)")
@@ -169,6 +231,19 @@ def main(argv: Optional[List[str]] = None) -> int:
     p_seq.add_argument("--preset", type=str, default=None)
     p_seq.add_argument("--sequence-file", type=str, default=None)
     p_seq.add_argument("--save-history", dest="save_history", type=str, default=None)
+    p_seq.add_argument("--export-history-base", dest="export_history_base", type=str, default=None)
+    p_seq.add_argument("--export-format", dest="export_format", choices=["csv", "json"], default="json")
+    p_seq.add_argument("--gamma-type", choices=list(GAMMA_REGISTRY.keys()), default="none")
+    p_seq.add_argument("--gamma-beta", type=float, default=0.0)
+    p_seq.add_argument("--gamma-R0", type=float, default=0.0)
+    p_seq.add_argument("--grammar.enabled", dest="grammar_enabled", type=_str2bool, default=None)
+    p_seq.add_argument("--grammar.zhir_requires_oz_window", dest="grammar_zhir_requires_oz_window", type=int, default=None)
+    p_seq.add_argument("--grammar.zhir_dnfr_min", dest="grammar_zhir_dnfr_min", type=float, default=None)
+    p_seq.add_argument("--grammar.thol_min_len", dest="grammar_thol_min_len", type=int, default=None)
+    p_seq.add_argument("--grammar.thol_max_len", dest="grammar_thol_max_len", type=int, default=None)
+    p_seq.add_argument("--grammar.thol_close_dnfr", dest="grammar_thol_close_dnfr", type=float, default=None)
+    p_seq.add_argument("--grammar.si_high", dest="grammar_si_high", type=float, default=None)
+    p_seq.add_argument("--glyph.hysteresis_window", dest="glyph_hysteresis_window", type=int, default=None)
     p_seq.set_defaults(func=cmd_sequence)
 
     p_met = sub.add_parser("metrics", help="Correr breve y volcar métricas clave")
@@ -178,7 +253,9 @@ def main(argv: Optional[List[str]] = None) -> int:
     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("--gamma-type", choices=list(GAMMA_REGISTRY.keys()), default="none")
+    p_met.add_argument("--gamma-beta", type=float, default=0.0)
+    p_met.add_argument("--gamma-R0", type=float, default=0.0)
     p_met.add_argument("--save", type=str, default=None)
     p_met.set_defaults(func=cmd_metrics)
 

{tnfr-4.1.0 → tnfr-4.3.0}/src/tnfr/constants.py

@@ -76,14 +76,19 @@ DEFAULTS: Dict[str, Any] = {
     "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
-    "REMESH_MIN_PHASE_SYNC": 0.85,     # media mínima de sincronía de fase en ventana
-    "REMESH_MAX_GLYPH_DISR": 0.35,     # media máxima de carga glífica disruptiva en ventana
-    "REMESH_LOG_EVENTS": True,         # guarda eventos y metadatos del RE’MESH
-
-    # RE’MESH: memoria τ y mezcla α
-    "REMESH_TAU": 8,                  # pasos hacia atrás
+    "REMESH_REQUIRE_STABILITY": False, # si True, exige ventana de estabilidad multi-métrica
+    "REMESH_STABILITY_WINDOW": 25,     # tamaño de ventana para evaluar estabilidad
+    "REMESH_MIN_PHASE_SYNC": 0.85,     # media mínima de sincronía de fase en ventana
+    "REMESH_MAX_GLYPH_DISR": 0.35,     # media máxima de carga glífica disruptiva en ventana
+    "REMESH_MIN_SIGMA_MAG": 0.50,      # magnitud mínima de σ en ventana
+    "REMESH_MIN_KURAMOTO_R": 0.80,    # R de Kuramoto mínimo en ventana
+    "REMESH_MIN_SI_HI_FRAC": 0.50,    # fracción mínima de nodos con Si alto
+    "REMESH_LOG_EVENTS": True,         # guarda eventos y metadatos del RE’MESH
+
+    # RE’MESH: memoria τ y mezcla α (global/local)
+    "REMESH_TAU": 8,                  # compatibilidad: tau global por defecto
+    "REMESH_TAU_GLOBAL": 8,           # pasos hacia atrás (escala global)
+    "REMESH_TAU_LOCAL": 4,            # pasos hacia atrás (escala local)
     "REMESH_ALPHA": 0.5,              # mezcla con pasado
     "REMESH_ALPHA_HARD": False,       # si True ignora GLYPH_FACTORS['REMESH_alpha']
 
@@ -177,11 +182,7 @@ DEFAULTS.setdefault("GRAMMAR_CANON", {
 
 def attach_defaults(G, override: bool = False) -> None:
     """Escribe DEFAULTS en G.graph (sin sobreescribir si override=False)."""
-    G.graph.setdefault("_tnfr_defaults_attached", False)
-    for k, v in DEFAULTS.items():
-        if override or k not in G.graph:
-            G.graph[k] = v
-    G.graph["_tnfr_defaults_attached"] = True
+    inject_defaults(G, DEFAULTS, override=override)
 
 
 def inject_defaults(G, defaults: Dict[str, Any] = DEFAULTS, override: bool = False) -> None:
@@ -210,7 +211,10 @@ def merge_overrides(G, **overrides) -> None:
 ALIAS_VF     = ("νf", "nu_f", "nu-f", "nu", "freq", "frequency")
 ALIAS_THETA  = ("θ", "theta", "fase", "phi", "phase")
 ALIAS_DNFR   = ("ΔNFR", "delta_nfr", "dnfr")
-ALIAS_EPI    = ("EPI", "psi", "PSI", "value")
-ALIAS_SI     = ("Si", "sense_index", "S_i", "sense", "meaning_index")
-ALIAS_dEPI   = ("dEPI_dt", "dpsi_dt", "dEPI", "velocity")
-ALIAS_D2EPI  = ("d2EPI_dt2", "d2psi_dt2", "d2EPI", "accel")
+ALIAS_EPI    = ("EPI", "psi", "PSI", "value")
+ALIAS_SI     = ("Si", "sense_index", "S_i", "sense", "meaning_index")
+ALIAS_dEPI   = ("dEPI_dt", "dpsi_dt", "dEPI", "velocity")
+ALIAS_D2EPI  = ("d2EPI_dt2", "d2psi_dt2", "d2EPI", "accel")
+ALIAS_dVF    = ("dνf_dt", "dvf_dt", "dnu_dt", "dvf")
+ALIAS_D2VF   = ("d2νf_dt2", "d2vf_dt2", "d2nu_dt2", "B")
+ALIAS_dSI    = ("δSi", "delta_Si", "dSi")

{tnfr-4.1.0 → tnfr-4.3.0}/src/tnfr/dynamics.py

@@ -19,7 +19,11 @@ import networkx as nx
 from .observers import sincronía_fase, carga_glifica, orden_kuramoto, sigma_vector
 from .operators import aplicar_remesh_si_estabilizacion_global
 from .grammar import select_and_apply_with_grammar
-from .constants import DEFAULTS, ALIAS_VF, ALIAS_THETA, ALIAS_DNFR, ALIAS_EPI, ALIAS_SI, ALIAS_dEPI, ALIAS_D2EPI
+from .constants import (
+    DEFAULTS,
+    ALIAS_VF, ALIAS_THETA, ALIAS_DNFR, ALIAS_EPI, ALIAS_SI,
+    ALIAS_dEPI, ALIAS_D2EPI, ALIAS_dVF, ALIAS_D2VF, ALIAS_dSI,
+)
 from .gamma import eval_gamma
 from .helpers import (
      clamp, clamp01, list_mean, phase_distance,
@@ -212,6 +216,17 @@ def aplicar_clamps_canonicos(nd: Dict[str, Any], G=None, node=None) -> None:
         _set_attr(nd, ALIAS_THETA, ((th + math.pi) % (2*math.pi) - math.pi))
 
 
+def validate_canon(G) -> None:
+    """Aplica clamps canónicos a todos los nodos de ``G``.
+
+    Envuelve fase y restringe ``EPI`` y ``νf`` a los rangos en ``G.graph``.
+    Si ``VALIDATORS_STRICT`` está activo, registra alertas en ``history``.
+    """
+    for n in G.nodes():
+        aplicar_clamps_canonicos(G.nodes[n], G, n)
+    return G
+
+
 def coordinar_fase_global_vecinal(G, fuerza_global: float | None = None, fuerza_vecinal: float | None = None) -> None:
     """
     Ajusta fase con mezcla GLOBAL+VECINAL.
@@ -425,6 +440,19 @@ def parametric_glyph_selector(G, n) -> str:
             prev = list(hist)[-1]
             if isinstance(prev, str) and prev in ("I’L","O’Z","Z’HIR","T’HOL","NA’V","R’A"):
                 return prev
+
+    # Penalización por falta de avance en σ/Si si se repite glifo
+    prev = None
+    hist_prev = nd.get("hist_glifos")
+    if hist_prev:
+        prev = list(hist_prev)[-1]
+    if prev == cand:
+        delta_si = _get_attr(nd, ALIAS_dSI, 0.0)
+        h = G.graph.get("history", {})
+        sig = h.get("sense_sigma_mag", [])
+        delta_sigma = sig[-1] - sig[-2] if len(sig) >= 2 else 0.0
+        if delta_si <= 0.0 and delta_sigma <= 0.0:
+            score -= 0.05
             
     # Override suave guiado por score (solo si NO cayó la histéresis arriba)
     # Regla: score>=0.66 inclina a I’L; score<=0.33 inclina a O’Z/Z’HIR
@@ -487,7 +515,9 @@ def step(G, *, dt: float | None = None, use_Si: bool = True, apply_glyphs: bool
     # 7) Observadores ligeros
     _update_history(G)
     # dynamics.py — dentro de step(), justo antes del punto 8)
-    tau = int(G.graph.get("REMESH_TAU", DEFAULTS["REMESH_TAU"]))
+    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 = max(tau_g, tau_l)
     maxlen = max(2 * tau + 5, 64)
     epi_hist = G.graph.get("_epi_hist")
     if not isinstance(epi_hist, deque) or epi_hist.maxlen != maxlen:
@@ -528,11 +558,12 @@ def run(G, steps: int, *, dt: float | None = None, use_Si: bool = True, apply_gl
 # -------------------------
 
 def _update_history(G) -> None:
-    hist = G.graph.setdefault("history", {
-        "C_steps": [], "stable_frac": [],
-        "phase_sync": [], "glyph_load_estab": [], "glyph_load_disr": [],
-        "Si_mean": [], "Si_hi_frac": [], "Si_lo_frac": []
-    })
+    hist = G.graph.setdefault("history", {})
+    for k in (
+        "C_steps", "stable_frac", "phase_sync", "glyph_load_estab", "glyph_load_disr",
+        "Si_mean", "Si_hi_frac", "Si_lo_frac", "delta_Si", "B"
+    ):
+        hist.setdefault(k, [])
 
     # Proxy de coherencia C(t)
     dnfr_mean = list_mean(abs(_get_attr(G.nodes[n], ALIAS_DNFR, 0.0)) for n in G.nodes())
@@ -552,11 +583,37 @@ def _update_history(G) -> None:
     eps_depi = float(G.graph.get("EPS_DEPI_STABLE", DEFAULTS["EPS_DEPI_STABLE"]))
     stables = 0
     total = max(1, G.number_of_nodes())
+    dt = float(G.graph.get("DT", DEFAULTS.get("DT", 1.0))) or 1.0
+    delta_si_acc = []
+    B_acc = []
     for n in G.nodes():
         nd = G.nodes[n]
         if abs(_get_attr(nd, ALIAS_DNFR, 0.0)) <= eps_dnfr and abs(_get_attr(nd, ALIAS_dEPI, 0.0)) <= eps_depi:
             stables += 1
+
+        # δSi por nodo
+        Si_curr = _get_attr(nd, ALIAS_SI, 0.0)
+        Si_prev = nd.get("_prev_Si", Si_curr)
+        dSi = Si_curr - Si_prev
+        nd["_prev_Si"] = Si_curr
+        _set_attr(nd, ALIAS_dSI, dSi)
+        delta_si_acc.append(dSi)
+
+        # Bifurcación B = ∂²νf/∂t²
+        vf_curr = _get_attr(nd, ALIAS_VF, 0.0)
+        vf_prev = nd.get("_prev_vf", vf_curr)
+        dvf_dt = (vf_curr - vf_prev) / dt
+        dvf_prev = nd.get("_prev_dvf", dvf_dt)
+        B = (dvf_dt - dvf_prev) / dt
+        nd["_prev_vf"] = vf_curr
+        nd["_prev_dvf"] = dvf_dt
+        _set_attr(nd, ALIAS_dVF, dvf_dt)
+        _set_attr(nd, ALIAS_D2VF, B)
+        B_acc.append(B)
+
     hist["stable_frac"].append(stables/total)
+    hist["delta_Si"].append(list_mean(delta_si_acc, 0.0))
+    hist["B"].append(list_mean(B_acc, 0.0))
     # --- nuevas series: sincronía de fase y carga glífica ---
     try:
         ps = sincronía_fase(G)                 # [0,1], más alto = más en fase

{tnfr-4.1.0 → tnfr-4.3.0}/src/tnfr/gamma.py

@@ -23,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]:
@@ -83,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-4.1.0 → tnfr-4.3.0}/src/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)
 # -------------------------

{tnfr-4.1.0 → tnfr-4.3.0}/src/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-4.1.0 → tnfr-4.3.0}/src/tnfr/operators.py

@@ -190,31 +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."""
-    hard = bool(G.graph.get("REMESH_ALPHA_HARD", DEFAULTS.get("REMESH_ALPHA_HARD", False)))
-    gf = G.graph.get("GLYPH_FACTORS", DEFAULTS["GLYPH_FACTORS"])
-    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"
+    """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(DEFAULTS["REMESH_ALPHA"]), "DEFAULTS"
+        return float(gf["REMESH_alpha"]), "GLYPH_FACTORS.REMESH_alpha"
+    if "REMESH_ALPHA" in G.graph:
+        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:
@@ -239,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())
@@ -253,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,
@@ -289,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", [])
@@ -311,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)

{tnfr-4.1.0 → tnfr-4.3.0}/src/tnfr/presets.py

@@ -16,6 +16,9 @@ _PRESETS = {
         "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-4.1.0 → tnfr-4.3.0}/src/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-4.1.0 → tnfr-4.3.0}/src/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-4.1.0 → tnfr-4.3.0}/src/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
@@ -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"}
@@ -103,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"}
@@ -119,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)

{tnfr-4.1.0 → tnfr-4.3.0/src/tnfr.egg-info}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: tnfr
-Version: 4.1.0
-Summary: TNFR canónica: dinámica glífica modular sobre redes.
+Version: 4.3.0
+Summary: Canonical TNFR: modular glyph-based dynamics on networks.
 Author: fmg
 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
+Keywords: TNFR,resonant fractal,resonance,glyphs,networkx,dynamics,coherence,EPI,Kuramoto
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.9
@@ -25,7 +25,13 @@ License-File: LICENSE.md
 Requires-Dist: networkx>=2.6
 Dynamic: license-file
 
-# General Project Structure
+# TNFR — Canonical Glyph-Based Dynamics
+
+Reference implementation of the Resonant Fractal Nature Theory (TNFR).
+It models glyph-driven dynamics on NetworkX graphs, providing a modular
+engine to simulate coherent reorganization processes.
+
+## General Project Structure
 
 * **Package entry point.** `__init__.py` registers modules under short names to avoid circular imports and exposes the public API: `preparar_red`, `step`, `run`, and observation utilities.
 

{tnfr-4.1.0 → tnfr-4.3.0}/src/tnfr.egg-info/SOURCES.txt

@@ -25,11 +25,13 @@ src/tnfr.egg-info/dependency_links.txt
 src/tnfr.egg-info/entry_points.txt
 src/tnfr.egg-info/requires.txt
 src/tnfr.egg-info/top_level.txt
+tests/test_canon.py
 tests/test_cli_sanity.py
 tests/test_edge_cases.py
 tests/test_gamma.py
 tests/test_grammar.py
 tests/test_history.py
+tests/test_history_series.py
 tests/test_invariants.py
 tests/test_program.py
 tests/test_remesh.py

tnfr-4.3.0/tests/test_canon.py

@@ -0,0 +1,30 @@
+from tnfr.scenarios import build_graph
+from tnfr.dynamics import validate_canon
+
+
+def test_build_graph_vf_within_limits():
+    G = build_graph(n=10, topology="ring", seed=42)
+    vf_min = G.graph["VF_MIN"]
+    vf_max = G.graph["VF_MAX"]
+    for n in G.nodes():
+        vf = G.nodes[n]["νf"]
+        assert vf_min <= vf <= vf_max
+
+
+def test_validate_canon_clamps():
+    G = build_graph(n=5, topology="ring", seed=1)
+    for n in G.nodes():
+        nd = G.nodes[n]
+        nd["νf"] = 2.0
+        nd["EPI"] = 2.0
+        nd["θ"] = 5.0
+    validate_canon(G)
+    vf_min = G.graph["VF_MIN"]
+    vf_max = G.graph["VF_MAX"]
+    epi_min = G.graph["EPI_MIN"]
+    epi_max = G.graph["EPI_MAX"]
+    for n in G.nodes():
+        nd = G.nodes[n]
+        assert vf_min <= nd["νf"] <= vf_max
+        assert epi_min <= nd["EPI"] <= epi_max
+        assert -3.1416 <= nd["θ"] <= 3.1416

{tnfr-4.1.0 → tnfr-4.3.0}/tests/test_edge_cases.py

@@ -1,5 +1,6 @@
 import pytest
 import networkx as nx
+import pytest
 
 from tnfr.dynamics import default_compute_delta_nfr, update_epi_via_nodal_equation
 

tnfr-4.3.0/tests/test_history_series.py

@@ -0,0 +1,27 @@
+import networkx as nx
+
+from tnfr.constants import attach_defaults
+from tnfr.dynamics import step
+from tnfr.gamma import GAMMA_REGISTRY
+
+
+def test_history_delta_si_and_B():
+    G = nx.Graph()
+    G.add_node(0, EPI=0.0, νf=0.5, θ=0.0)
+    attach_defaults(G)
+    step(G, apply_glyphs=False)
+    step(G, apply_glyphs=False)
+    hist = G.graph.get("history", {})
+    assert "delta_Si" in hist and len(hist["delta_Si"]) >= 2
+    assert "B" in hist and len(hist["B"]) >= 2
+
+
+def test_gamma_kuramoto_tanh_registry():
+    G = nx.Graph()
+    G.add_nodes_from([0, 1])
+    attach_defaults(G)
+    G.nodes[0]["θ"] = 0.0
+    G.nodes[1]["θ"] = 0.0
+    cfg = {"type": "kuramoto_tanh", "beta": 0.5, "k": 2.0, "R0": 0.0}
+    val = GAMMA_REGISTRY["kuramoto_tanh"](G, 0, 0.0, cfg)
+    assert abs(val) <= cfg["beta"]

{tnfr-4.1.0 → tnfr-4.3.0}/tests/test_invariants.py

@@ -2,6 +2,11 @@ from __future__ import annotations
 import math
 import pytest
 
+from tnfr.constants import inject_defaults, DEFAULTS
+from tnfr.scenarios import build_graph
+import math
+import pytest
+
 from tnfr.constants import inject_defaults, DEFAULTS
 from tnfr.scenarios import build_graph
 from tnfr.dynamics import step, _update_history

{tnfr-4.1.0 → tnfr-4.3.0}/tests/test_remesh.py

@@ -1,5 +1,6 @@
 import networkx as nx
 from collections import deque
+import networkx as nx
 
 from tnfr.constants import attach_defaults
 from tnfr.operators import aplicar_remesh_si_estabilizacion_global
@@ -27,3 +28,21 @@ def test_aplicar_remesh_usa_parametro_personalizado():
     aplicar_remesh_si_estabilizacion_global(G, pasos_estables_consecutivos=3)
     assert G.graph["_last_remesh_step"] == len(hist["stable_frac"])
 
+
+def test_remesh_alpha_hard_ignores_glyph_factor():
+    G = nx.Graph()
+    G.add_node(0)
+    attach_defaults(G)
+    hist = G.graph.setdefault("history", {})
+    hist["stable_frac"] = [1.0, 1.0, 1.0]
+    tau = G.graph["REMESH_TAU"]
+    maxlen = max(2 * tau + 5, 64)
+    G.graph["_epi_hist"] = deque([{0: 0.0} for _ in range(tau + 1)], maxlen=maxlen)
+    G.graph["REMESH_ALPHA"] = 0.7
+    G.graph["REMESH_ALPHA_HARD"] = True
+    G.graph["GLYPH_FACTORS"]["REMESH_alpha"] = 0.1
+    aplicar_remesh_si_estabilizacion_global(G, pasos_estables_consecutivos=3)
+    meta = G.graph.get("_REMESH_META", {})
+    assert meta.get("alpha") == 0.7
+    assert G.graph.get("_REMESH_ALPHA_SRC") == "REMESH_ALPHA"
+