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

tnfr/grammar.py

@@ -0,0 +1,155 @@
+from __future__ import annotations
+from typing import Dict, Any, Set
+
+from .constants import (
+    DEFAULTS,
+    ALIAS_SI, ALIAS_DNFR, ALIAS_EPI,
+)
+from .helpers import _get_attr, clamp01, reciente_glifo
+from collections import deque
+
+# Glifos nominales (para evitar typos)
+AL = "A’L"; EN = "E’N"; IL = "I’L"; OZ = "O’Z"; UM = "U’M"; RA = "R’A"; SHA = "SH’A"; VAL = "VA’L"; NUL = "NU’L"; THOL = "T’HOL"; ZHIR = "Z’HIR"; NAV = "NA’V"; REMESH = "RE’MESH"
+
+# -------------------------
+# Estado de gramática por nodo
+# -------------------------
+
+def _gram_state(nd: Dict[str, Any]) -> Dict[str, Any]:
+    """Crea/retorna el estado de gramática nodal.
+    Campos:
+      - thol_open (bool)
+      - thol_len (int)
+    """
+    st = nd.setdefault("_GRAM", {"thol_open": False, "thol_len": 0})
+    st.setdefault("thol_open", False)
+    st.setdefault("thol_len", 0)
+    return st
+
+# -------------------------
+# Compatibilidades canónicas (siguiente permitido)
+# -------------------------
+CANON_COMPAT: Dict[str, Set[str]] = {
+    # Inicio / apertura
+    AL:   {EN, RA, NAV, VAL, UM},
+    EN:   {IL, UM, RA, NAV},
+    # Estabilización / difusión / acople
+    IL:   {RA, VAL, UM, SHA},
+    UM:   {RA, IL, VAL, NAV},
+    RA:   {IL, VAL, UM, NAV},
+    VAL:  {UM, RA, IL, NAV},
+    # Disonancia → transición → mutación
+    OZ:   {ZHIR, NAV},
+    ZHIR: {IL, NAV},
+    NAV:  {OZ, ZHIR, RA, IL, UM},
+    # Cierres / latencias
+    SHA:  {AL, EN},
+    NUL:  {AL, IL},
+    # Bloques autoorganizativos
+    THOL: {OZ, ZHIR, NAV, RA, IL, UM, SHA, NUL},
+}
+
+# Fallbacks canónicos si una transición no está permitida
+CANON_FALLBACK: Dict[str, str] = {
+    AL: EN, EN: IL, IL: RA, UM: RA, RA: IL, VAL: RA, OZ: ZHIR, ZHIR: IL, NAV: RA, SHA: AL, NUL: AL, THOL: NAV,
+}
+
+# -------------------------
+# Cierres T’HOL y precondiciones Z’HIR
+# -------------------------
+
+def _dnfr_norm(G, nd) -> float:
+    # Normalizador robusto: usa historial de |ΔNFR| máx guardado por dynamics (si existe)
+    norms = G.graph.get("_sel_norms") or {}
+    dmax = float(norms.get("dnfr_max", 1.0)) or 1.0
+    return clamp01(abs(_get_attr(nd, ALIAS_DNFR, 0.0)) / dmax)
+
+
+def _si(G, nd) -> float:
+    return clamp01(_get_attr(nd, ALIAS_SI, 0.5))
+
+# -------------------------
+# Núcleo: forzar gramática sobre un candidato
+# -------------------------
+
+def enforce_canonical_grammar(G, n, cand: str) -> str:
+    """Valida/ajusta el glifo candidato según la gramática canónica.
+
+    Reglas clave:
+      - Compatibilidades de transición glífica (recorrido TNFR).
+      - O’Z→Z’HIR: la mutación requiere disonancia reciente o |ΔNFR| alto.
+      - T’HOL[...]: obliga cierre con SH’A o NU’L cuando el campo se estabiliza
+        o se alcanza el largo del bloque; mantiene estado por nodo.
+
+    Devuelve el glifo efectivo a aplicar.
+    """
+    nd = G.nodes[n]
+    st = _gram_state(nd)
+    cfg = G.graph.get("GRAMMAR_CANON", DEFAULTS.get("GRAMMAR_CANON", {}))
+
+    # 0) Si vienen glifos fuera del alfabeto, no tocamos
+    if cand not in CANON_COMPAT:
+        return cand
+
+    # 1) Precondición O’Z→Z’HIR: mutación requiere disonancia reciente o campo fuerte
+    if cand == ZHIR:
+        win = int(cfg.get("zhir_requires_oz_window", 3))
+        dn_min = float(cfg.get("zhir_dnfr_min", 0.05))
+        if not reciente_glifo(nd, OZ, win) and _dnfr_norm(G, nd) < dn_min:
+            cand = OZ  # forzamos paso por O’Z
+
+    # 2) Si estamos dentro de T’HOL, control de cierre obligado
+    if st.get("thol_open", False):
+        st["thol_len"] = int(st.get("thol_len", 0))
+        st["thol_len"] += 1
+        minlen = int(cfg.get("thol_min_len", 2))
+        maxlen = int(cfg.get("thol_max_len", 6))
+        close_dn = float(cfg.get("thol_close_dnfr", 0.15))
+        if st["thol_len"] >= maxlen or (st["thol_len"] >= minlen and _dnfr_norm(G, nd) <= close_dn):
+            cand = NUL if _si(G, nd) >= float(cfg.get("si_high", 0.66)) else SHA
+
+    # 3) Compatibilidades: si el anterior restringe el siguiente
+    prev = None
+    hist = nd.get("hist_glifos")
+    if hist:
+        try:
+            prev = list(hist)[-1]
+        except Exception:
+            prev = None
+    if prev in CANON_COMPAT and cand not in CANON_COMPAT[prev]:
+        cand = CANON_FALLBACK.get(prev, cand)
+
+    return cand
+
+# -------------------------
+# Post-selección: actualizar estado de gramática
+# -------------------------
+
+def on_applied_glifo(G, n, applied: str) -> None:
+    nd = G.nodes[n]
+    st = _gram_state(nd)
+    if applied == THOL:
+        st["thol_open"] = True
+        st["thol_len"] = 0
+    elif applied in (SHA, NUL):
+        st["thol_open"] = False
+        st["thol_len"] = 0
+    else:
+        pass
+
+# -------------------------
+# Integración con dynamics.step: helper de selección+aplicación
+# -------------------------
+
+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)
+    aplicar_glifo(G, n, cand, window=window)
+    on_applied_glifo(G, n, cand)

tnfr/helpers.py

@@ -4,7 +4,7 @@ helpers.py — TNFR canónica
 Utilidades transversales + cálculo de Índice de sentido (Si).
 """
 from __future__ import annotations
-from typing import Iterable, Dict, Any, Tuple, List
+from typing import Iterable, Dict, Any
 import math
 from collections import deque
 from statistics import fmean, StatisticsError
@@ -21,19 +21,23 @@ from .constants import DEFAULTS, ALIAS_VF, ALIAS_THETA, ALIAS_DNFR, ALIAS_EPI, A
 # -------------------------
 
 def clamp(x: float, a: float, b: float) -> float:
+    """Constriñe ``x`` al intervalo cerrado [a, b]."""
     return a if x < a else b if x > b else x
 
 
 def clamp_abs(x: float, m: float) -> float:
+    """Limita ``x`` al rango simétrico [-m, m] usando ``abs(m)``."""
     m = abs(m)
     return clamp(x, -m, m)
 
 
 def clamp01(x: float) -> float:
+    """Ataja ``x`` a la banda [0, 1]."""
     return clamp(x, 0.0, 1.0)
 
 
 def list_mean(xs: Iterable[float], default: float = 0.0) -> float:
+    """Promedio aritmético o ``default`` si ``xs`` está vacío."""
     try:
         return fmean(xs)
     except StatisticsError:
@@ -77,16 +81,14 @@ def _set_attr(d, aliases, value: float) -> None:
 # -------------------------
 
 def media_vecinal(G, n, aliases: Iterable[str], default: float = 0.0) -> float:
-    vals: List[float] = []
-    for v in G.neighbors(n):
-        vals.append(_get_attr(G.nodes[v], aliases, default))
+    """Media del atributo indicado por ``aliases`` en los vecinos de ``n``."""
+    vals = (_get_attr(G.nodes[v], aliases, default) for v in G.neighbors(n))
     return list_mean(vals, default)
 
 
 def fase_media(G, n) -> float:
     """Promedio circular de las fases de los vecinos."""
-    x = 0.0
-    y = 0.0
+    x = y = 0.0
     count = 0
     for v in G.neighbors(n):
         th = _get_attr(G.nodes[v], ALIAS_THETA, 0.0)
@@ -95,7 +97,7 @@ def fase_media(G, n) -> float:
         count += 1
     if count == 0:
         return _get_attr(G.nodes[n], ALIAS_THETA, 0.0)
-    return math.atan2(y / max(1, count), x / max(1, count))
+    return math.atan2(y / count, x / count)
 
 
 # -------------------------
@@ -103,16 +105,24 @@ def fase_media(G, n) -> float:
 # -------------------------
 
 def push_glifo(nd: Dict[str, Any], glifo: str, window: int) -> None:
+    """Añade ``glifo`` al historial del nodo con tamaño máximo ``window``."""
     hist = nd.setdefault("hist_glifos", deque(maxlen=window))
     hist.append(str(glifo))
 
 
 def reciente_glifo(nd: Dict[str, Any], glifo: str, ventana: int) -> bool:
+    """Indica si ``glifo`` apareció en las últimas ``ventana`` emisiones."""
     hist = nd.get("hist_glifos")
     if not hist:
         return False
-    last = list(hist)[-ventana:]
-    return str(glifo) in last
+    gl = str(glifo)
+    for g in reversed(hist):
+        if g == gl:
+            return True
+        ventana -= 1
+        if ventana <= 0:
+            break
+    return False
 
 # -------------------------
 # Callbacks Γ(R)
@@ -130,10 +140,26 @@ def _ensure_callbacks(G):
         cbs.setdefault(k, [])
     return cbs
 
-def register_callback(G, event: str, func):
-    """Registra un callback en G.graph['callbacks'][event]. Firma: func(G, ctx) -> None"""
+def register_callback(
+    G,
+    event: str | None = None,
+    func=None,
+    *,
+    when: str | None = None,
+    name: str | None = None,
+):
+    """Registra ``func`` como callback del ``event`` indicado.
+
+    Permite tanto la forma posicional ``register_callback(G, "after_step", fn)``
+    como la forma con palabras clave ``register_callback(G, when="after_step", func=fn)``.
+    El parámetro ``name`` se acepta por compatibilidad pero actualmente no se
+    utiliza.
+    """
+    event = event or when
     if event not in ("before_step", "after_step", "on_remesh"):
         raise ValueError(f"Evento desconocido: {event}")
+    if func is None:
+        raise TypeError("func es obligatorio")
     cbs = _ensure_callbacks(G)
     cbs[event].append(func)
     return func
@@ -160,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))
@@ -170,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/main.py

@@ -1,7 +1,11 @@
 from __future__ import annotations
-import argparse, sys
-import networkx as nx
-from . import preparar_red, run, __version__
+import argparse, sys
+import networkx as nx
+from . import preparar_red, run, __version__
+from .constants import merge_overrides, attach_defaults
+from .sense import register_sigma_callback
+from .metrics import register_metrics_callbacks
+from .trace import register_trace
 
 def main(argv: list[str] | None = None) -> None:
     p = argparse.ArgumentParser(
@@ -15,13 +19,19 @@ def main(argv: list[str] | None = None) -> None:
     p.add_argument("--observer", action="store_true", help="adjunta observador estándar")
     args = p.parse_args(argv)
 
-    if args.version:
-        print(__version__)
-        return
-
-    G = nx.erdos_renyi_graph(args.n, args.p)
-    preparar_red(G, ATTACH_STD_OBSERVER=bool(args.observer))
-    run(G, args.steps)
+    if args.version:
+        print(__version__)
+        return
+
+    G = nx.erdos_renyi_graph(args.n, args.p)
+    preparar_red(G, ATTACH_STD_OBSERVER=bool(args.observer))
+    attach_defaults(G)
+    register_sigma_callback(G)
+    register_metrics_callbacks(G)
+    register_trace(G)
+    # Ejemplo: activar Γi(R) lineal con β=0.2 y R0=0.5
+    merge_overrides(G, GAMMA={"type": "kuramoto_linear", "beta": 0.2, "R0": 0.5})
+    run(G, args.steps)
 
     h = G.graph.get("history", {})
     C = h.get("C_steps", [])[-1] if h.get("C_steps") else None

tnfr/metrics.py

@@ -0,0 +1,211 @@
+from __future__ import annotations
+from typing import Dict, Any, List, Tuple
+from collections import defaultdict, Counter
+import statistics
+
+from .constants import DEFAULTS
+from .helpers import _get_attr, clamp01, register_callback
+from .sense import GLYPHS_CANONICAL
+
+# -------------
+# DEFAULTS
+# -------------
+DEFAULTS.setdefault("METRICS", {
+    "enabled": True,
+    "save_by_node": True,     # guarda Tg por nodo (más pesado)
+    "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
+# -------------
+
+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
+
+
+# -------------
+# Callback principal: actualizar métricas por paso
+# -------------
+
+def _metrics_step(G, *args, **kwargs):
+    """Actualiza métricas operativas TNFR por paso.
+
+    - Tg (tiempo glífico): sumatoria de corridas por glifo (global y por nodo).
+    - Índice de latencia: fracción de nodos en SH’A.
+    - Glifograma: conteo o fracción por glifo en el paso.
+
+    Todos los resultados se guardan en G.graph['history'].
+    """
+    if not G.graph.get("METRICS", DEFAULTS.get("METRICS", {})).get("enabled", True):
+        return
+
+    hist = _ensure_history(G)
+    dt = float(G.graph.get("DT", 1.0))
+    t = float(G.graph.get("_t", 0.0))
+
+    # --- Glifograma (conteos por glifo este paso) ---
+    counts = Counter()
+
+    # --- Índice de latencia: proporción de nodos en SH’A ---
+    n_total = 0
+    n_latent = 0
+
+    # --- Tg: acumular corridas por nodo ---
+    save_by_node = bool(G.graph.get("METRICS", DEFAULTS["METRICS"]).get("save_by_node", True))
+    tg_total = hist.setdefault("Tg_total", defaultdict(float))  # tiempo total por glifo (global)
+    tg_by_node = hist.setdefault("Tg_by_node", {})             # nodo → {glifo: [runs,...]}
+
+    for n in G.nodes():
+        nd = G.nodes[n]
+        g = _last_glifo(nd)
+        if not g:
+            continue
+
+        n_total += 1
+        if g == "SH’A":
+            n_latent += 1
+
+        counts[g] += 1
+
+        st = _tg_state(nd)
+        # Si seguimos en el mismo glifo, acumulamos; si cambiamos, cerramos corrida
+        if st["curr"] is None:
+            st["curr"] = g
+            st["run"] = dt
+        elif g == st["curr"]:
+            st["run"] += dt
+        else:
+            # cerramos corrida anterior
+            prev = st["curr"]
+            dur = float(st["run"])
+            tg_total[prev] += dur
+            if save_by_node:
+                rec = tg_by_node.setdefault(n, defaultdict(list))
+                rec[prev].append(dur)
+            # reiniciamos corrida
+            st["curr"] = g
+            st["run"] = dt
+
+    # Al final del paso, no cerramos la corrida actual: se cerrará cuando cambie.
+
+    # Guardar glifograma (conteos crudos y normalizados)
+    norm = bool(G.graph.get("METRICS", DEFAULTS["METRICS"]).get("normalize_series", False))
+    row = {"t": t}
+    total = max(1, sum(counts.values()))
+    for g in GLYPHS_CANONICAL:
+        c = counts.get(g, 0)
+        row[g] = (c / total) if norm else c
+    hist.setdefault("glifogram", []).append(row)
+
+    # Guardar índice de latencia
+    li = (n_latent / max(1, n_total)) if n_total else 0.0
+    hist.setdefault("latency_index", []).append({"t": t, "value": li})
+
+
+# -------------
+# Registro del callback
+# -------------
+
+def register_metrics_callbacks(G) -> None:
+    register_callback(G, when="after_step", func=_metrics_step, name="metrics_step")
+
+
+# -------------
+# Consultas / reportes
+# -------------
+
+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)
+    tg_total: Dict[str, float] = hist.get("Tg_total", {})
+    total = sum(tg_total.values()) or 1.0
+    if normalize:
+        return {g: float(tg_total.get(g, 0.0)) / total for g in GLYPHS_CANONICAL}
+    return {g: float(tg_total.get(g, 0.0)) for g in GLYPHS_CANONICAL}
+
+
+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)
+    rec = hist.get("Tg_by_node", {}).get(n, {})
+    if not normalize:
+        # convertir default dict → list para serializar
+        return {g: list(rec.get(g, [])) for g in GLYPHS_CANONICAL}
+    out = {}
+    for g in GLYPHS_CANONICAL:
+        runs = rec.get(g, [])
+        out[g] = float(statistics.mean(runs)) if runs else 0.0
+        
+    return out
+
+
+def latency_series(G) -> Dict[str, List[float]]:
+    hist = _ensure_history(G)
+    xs = hist.get("latency_index", [])
+    return {
+        "t": [float(x.get("t", i)) for i, x in enumerate(xs)],
+        "value": [float(x.get("value", 0.0)) for x in xs],
+    }
+
+
+def glifogram_series(G) -> Dict[str, List[float]]:
+    hist = _ensure_history(G)
+    xs = hist.get("glifogram", [])
+    if not xs:
+        return {"t": []}
+    out = {"t": [float(x.get("t", i)) for i, x in enumerate(xs)]}
+    for g in GLYPHS_CANONICAL:
+        out[g] = [float(x.get(g, 0.0)) for x in xs]
+    return out
+
+
+def glyph_top(G, k: int = 3) -> List[Tuple[str, float]]:
+    """Top-k glifos por Tg_global (fracción)."""
+    tg = Tg_global(G, normalize=True)
+    return sorted(tg.items(), key=lambda kv: kv[1], reverse=True)[:max(1, int(k))]
+
+
+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)
+    rec = hist.get("Tg_by_node", {}).get(n, {})
+    out = {}
+    for g in GLYPHS_CANONICAL:
+        runs = list(rec.get(g, []))
+        if not runs:
+            out[g] = {"mean": 0.0, "median": 0.0, "max": 0.0, "count": 0}
+        else:
+            out[g] = {
+                "mean": float(statistics.mean(runs)),
+                "median": float(statistics.median(runs)),
+                "max": float(max(runs)),
+                "count": int(len(runs)),
+            }
+    return out

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)
@@ -154,6 +163,18 @@ _NAME_TO_OP = {
 
 
 def aplicar_glifo(G, n, glifo: str, *, window: Optional[int] = None) -> None:
+    """Aplica un glifo TNFR al nodo `n` con histéresis `window`.
+
+    Los 13 glifos implementan reorganizadores canónicos:
+      A’L (emisión), E’N (recepción), I’L (coherencia), O’Z (disonancia),
+      U’M (acoplamiento), R’A (resonancia), SH’A (silencio), VA’L (expansión),
+      NU’L (contracción), T’HOL (autoorganización), Z’HIR (mutación),
+      NA’V (transición), RE’MESH (recursividad).
+
+    Relación con la gramática: la selección previa debe pasar por
+    `enforce_canonical_grammar` (grammar.py) para respetar compatibilidades,
+    precondición O’Z→Z’HIR y cierres T’HOL[...].
+    """
     glifo = str(glifo)
     op = _NAME_TO_OP.get(glifo)
     if not op:
@@ -169,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"
 
 
@@ -296,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

@@ -0,0 +1,25 @@
+from __future__ import annotations
+from .program import seq, block, wait, ejemplo_canonico_basico
+
+
+_PRESETS = {
+    "arranque_resonante": seq("A’L", "E’N", "I’L", "R’A", "VA’L", "U’M", wait(3), "SH’A"),
+    "mutacion_contenida": seq("A’L", "E’N", block("O’Z", "Z’HIR", "I’L", repeat=2), "R’A", "SH’A"),
+    "exploracion_acople": seq(
+        "A’L",
+        "E’N",
+        "I’L",
+        "VA’L",
+        "U’M",
+        block("O’Z", "NA’V", "I’L", repeat=1),
+        "R’A",
+        "SH’A",
+    ),
+    "ejemplo_canonico": ejemplo_canonico_basico(),
+}
+
+
+def get_preset(name: str):
+    if name not in _PRESETS:
+        raise KeyError(f"Preset no encontrado: {name}")
+    return _PRESETS[name]