tnfr 4.5.0__tar.gz → 4.5.1__tar.gz

tnfr-4.5.1/PKG-INFO

@@ -0,0 +1,221 @@
+Metadata-Version: 2.4
+Name: tnfr
+Version: 4.5.1
+Summary: modular structural-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,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
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: networkx>=2.6
+Dynamic: license-file
+
+# tnfr · Python package
+
+> Engine for **modeling, simulation, and measurement** of multiscale structural coherence through **structural operators** (emission, reception, coherence, dissonance, coupling, resonance, silence, expansion, contraction, self‑organization, mutation, transition, recursivity).
+
+---
+
+## What is `tnfr`?
+
+`tnfr` is a Python library to **operate with form**: build nodes, couple them into networks, and **modulate their coherence** over time using structural operators. It does not describe “things”; it **activates processes**. Its theoretical basis is the Resonant Fractal Nature Theory (TNFR), which understands reality as **networks of coherence** that persist because they **resonate**.
+
+In practical terms, `tnfr` lets you:
+
+* Model **Resonant Fractal Nodes (NFR)** with parameters for **frequency** (νf), **phase** (θ), and **form** (EPI).
+* Apply **structural operators** to start, stabilize, propagate, or reconfigure coherence.
+* **Simulate** nodal dynamics with discrete/continuous integrators.
+* **Measure** global coherence C(t), nodal gradient ΔNFR, and the **Sense Index** (Si).
+* **Visualize** states and trajectories (coupling matrices, C(t) curves, graphs).
+
+> **Nodal equation (operational core)**
+>
+> $\frac{\partial \mathrm{EPI}}{\partial t} = \nu_f\,\cdot\,\Delta\mathrm{NFR}(t)$
+>
+> A form emerges and persists when **internal reorganization** (ΔNFR) **resonates** with the node’s **frequency** (νf).
+
+---
+
+## Installation
+
+```bash
+pip install tnfr
+```
+
+Requires **Python ≥ 3.9**.
+
+---
+
+## Why TNFR (in 60 seconds)
+
+* **From objects to coherences:** you model **processes** that hold, not fixed entities.
+* **Operators instead of rules:** you compose **structural operators** (e.g., *emission*, *coherence*, *dissonance*) to **build trajectories**.
+* **Operational fractality:** the same pattern works for **ideas, teams, tissues, narratives**; the scales change, **the logic doesn’t**.
+
+---
+
+## Getting started (minimal recipe)
+
+> *The high‑level API centers on three things: nodes, operators, simulation.*
+
+```python
+# 1) Nodes and network
+import tnfr as T
+
+# A minimal set of nodes with initial frequency (νf)
+A = T.Node(label="seed", nu_f=0.8)
+B = T.Node(label="context", nu_f=0.6)
+net = T.Network([A, B], edges=[(A, B, 0.7)])  # coupling 0..1
+
+# 2) Sequence of structural operators
+ops = [
+    T.ops.Emission(strength=0.4),      # start pattern
+    T.ops.Coupling(weight=0.7),        # synchronize nodes
+    T.ops.Coherence(),                 # stabilize form
+]
+
+# 3) Simulation and metrics
+traj = T.sim.run(net, ops, steps=200, dt=0.05)
+print("C(t) =", T.metrics.coherence(traj)[-1])
+print("Si   =", T.metrics.sense_index(traj))
+
+# 4) Quick visualization
+T.viz.plot_coherence(traj)     # C(t) curve
+T.viz.plot_network(net)        # graph/couplings
+```
+
+> **Note:** Specific class/function names may vary across minor versions. Check `help(T.ops)` and `help(T.sim)` for your installed API.
+
+---
+
+## Key concepts (operational summary)
+
+* **Node (NFR):** a unit that persists because it **resonates**. Parameterized by **νf** (frequency), **θ** (phase), and **EPI** (coherent form).
+* **Structural operators:** functions that reorganize the network. We use **functional** names (not phonemes):
+
+  * **Emission** (start), **Reception** (open), **Coherence** (stabilize), **Dissonance** (creative tension), **Coupling** (synchrony), **Resonance** (propagate), **Silence** (latency), **Expansion**, **Contraction**, **Self‑organization**, **Mutation**, **Transition**, **Recursivity**.
+* **Magnitudes:**
+
+  * **C(t):** global coherence.
+  * **ΔNFR:** nodal gradient (need for reorganization).
+  * **νf:** structural frequency (Hz\_str).
+  * **Si:** sense index (ability to generate stable shared coherence).
+
+---
+
+## Typical workflow
+
+1. **Model** your system as a network: nodes (agents, ideas, tissues, modules) and couplings.
+2. **Select** a **trajectory of operators** aligned with your goal (e.g., *start → couple → stabilize*).
+3. **Simulate** the dynamics: number of steps, step size, tolerances.
+4. **Measure**: C(t), ΔNFR, Si; identify bifurcations and collapses.
+5. **Iterate** with controlled **dissonance** to open mutations without losing form.
+
+---
+
+## High‑level API (orientation map)
+
+> The typical module layout in `tnfr` is:
+
+* `tnfr.core`: `Node`, `Network`, `EPI`, `State`
+* `tnfr.ops`: structural operators (Emission, Reception, Coherence, Dissonance, ...)
+* `tnfr.sim`: integrators (`run`, `step`, `integrate`), dt control and thresholds
+* `tnfr.metrics`: `coherence`, `gradient`, `sense_index`, `phase_sync`
+* `tnfr.viz`: plotting utilities (`plot_coherence`, `plot_network`, `plot_phase`)
+
+Usage examples:
+
+```python
+from tnfr import core, ops, sim, metrics
+
+net = core.Network.from_edges([
+    ("n1", "n2", 0.6),
+    ("n2", "n3", 0.8),
+])
+
+sequence = [ops.Emission(0.3), ops.Coupling(0.5), ops.Coherence()]
+traj = sim.run(net, sequence, steps=500)
+
+print(metrics.coherence(traj))
+```
+
+---
+
+## Parametric modeling
+
+```python
+import tnfr as T
+
+net = T.Network.uniform(n=25, nu_f=0.4, coupling=0.3)
+plan = (
+    T.ops.Emission(0.2)
+  >> T.ops.Expansion(0.4)
+  >> T.ops.Coupling(0.6)
+  >> T.ops.Coherence()
+)
+traj = T.sim.run(net, plan, steps=800)
+T.viz.plot_phase(traj)
+```
+
+---
+
+## Main metrics
+
+* `coherence(traj) → C(t)`: global stability; higher values indicate sustained form.
+* `gradient(state) → ΔNFR`: local demand for reorganization (high = risk of collapse/bifurcation).
+* `sense_index(traj) → Si`: proxy for **structural sense** (capacity to generate shared coherence) combining **νf**, phase, and topology.
+
+---
+
+## Best practices
+
+* **Short sequences** and frequent C(t) checks avoid unnecessary collapses.
+* Use **dissonance** as a tool: introduce it to open possibilities, but **seal** with coherence.
+* **Scale first, detail later:** tune coarse couplings before micro‑parameters.
+
+---
+
+## Project status
+
+* **pre‑1.0 API**: signatures may be refined; concepts and magnitudes are stable.
+* **Pure‑Python** core with minimal dependencies (optional: `numpy`, `matplotlib`, `networkx`).
+
+---
+
+## Contributing
+
+Suggestions, issues, and PRs are welcome. Guidelines:
+
+1. Prioritize **operational clarity** (names, docstrings, examples).
+2. Add **tests** and **notebooks** that show the structural effect of each PR.
+3. Keep **semantic neutrality**: operators act on form, not on contents.
+
+---
+
+## License
+
+MIT 
+
+---
+
+## References & notes
+
+* Theoretical foundations: TNFR operational manual.
+* Operational definitions: nodal equation, dimensions (frequency, phase, form), and structural operators.
+
+> If you use `tnfr` in research or projects, please cite the TNFR conceptual framework and link to the PyPI package.

tnfr-4.5.1/README.md

@@ -0,0 +1,194 @@
+# tnfr · Python package
+
+> Engine for **modeling, simulation, and measurement** of multiscale structural coherence through **structural operators** (emission, reception, coherence, dissonance, coupling, resonance, silence, expansion, contraction, self‑organization, mutation, transition, recursivity).
+
+---
+
+## What is `tnfr`?
+
+`tnfr` is a Python library to **operate with form**: build nodes, couple them into networks, and **modulate their coherence** over time using structural operators. It does not describe “things”; it **activates processes**. Its theoretical basis is the Resonant Fractal Nature Theory (TNFR), which understands reality as **networks of coherence** that persist because they **resonate**.
+
+In practical terms, `tnfr` lets you:
+
+* Model **Resonant Fractal Nodes (NFR)** with parameters for **frequency** (νf), **phase** (θ), and **form** (EPI).
+* Apply **structural operators** to start, stabilize, propagate, or reconfigure coherence.
+* **Simulate** nodal dynamics with discrete/continuous integrators.
+* **Measure** global coherence C(t), nodal gradient ΔNFR, and the **Sense Index** (Si).
+* **Visualize** states and trajectories (coupling matrices, C(t) curves, graphs).
+
+> **Nodal equation (operational core)**
+>
+> $\frac{\partial \mathrm{EPI}}{\partial t} = \nu_f\,\cdot\,\Delta\mathrm{NFR}(t)$
+>
+> A form emerges and persists when **internal reorganization** (ΔNFR) **resonates** with the node’s **frequency** (νf).
+
+---
+
+## Installation
+
+```bash
+pip install tnfr
+```
+
+Requires **Python ≥ 3.9**.
+
+---
+
+## Why TNFR (in 60 seconds)
+
+* **From objects to coherences:** you model **processes** that hold, not fixed entities.
+* **Operators instead of rules:** you compose **structural operators** (e.g., *emission*, *coherence*, *dissonance*) to **build trajectories**.
+* **Operational fractality:** the same pattern works for **ideas, teams, tissues, narratives**; the scales change, **the logic doesn’t**.
+
+---
+
+## Getting started (minimal recipe)
+
+> *The high‑level API centers on three things: nodes, operators, simulation.*
+
+```python
+# 1) Nodes and network
+import tnfr as T
+
+# A minimal set of nodes with initial frequency (νf)
+A = T.Node(label="seed", nu_f=0.8)
+B = T.Node(label="context", nu_f=0.6)
+net = T.Network([A, B], edges=[(A, B, 0.7)])  # coupling 0..1
+
+# 2) Sequence of structural operators
+ops = [
+    T.ops.Emission(strength=0.4),      # start pattern
+    T.ops.Coupling(weight=0.7),        # synchronize nodes
+    T.ops.Coherence(),                 # stabilize form
+]
+
+# 3) Simulation and metrics
+traj = T.sim.run(net, ops, steps=200, dt=0.05)
+print("C(t) =", T.metrics.coherence(traj)[-1])
+print("Si   =", T.metrics.sense_index(traj))
+
+# 4) Quick visualization
+T.viz.plot_coherence(traj)     # C(t) curve
+T.viz.plot_network(net)        # graph/couplings
+```
+
+> **Note:** Specific class/function names may vary across minor versions. Check `help(T.ops)` and `help(T.sim)` for your installed API.
+
+---
+
+## Key concepts (operational summary)
+
+* **Node (NFR):** a unit that persists because it **resonates**. Parameterized by **νf** (frequency), **θ** (phase), and **EPI** (coherent form).
+* **Structural operators:** functions that reorganize the network. We use **functional** names (not phonemes):
+
+  * **Emission** (start), **Reception** (open), **Coherence** (stabilize), **Dissonance** (creative tension), **Coupling** (synchrony), **Resonance** (propagate), **Silence** (latency), **Expansion**, **Contraction**, **Self‑organization**, **Mutation**, **Transition**, **Recursivity**.
+* **Magnitudes:**
+
+  * **C(t):** global coherence.
+  * **ΔNFR:** nodal gradient (need for reorganization).
+  * **νf:** structural frequency (Hz\_str).
+  * **Si:** sense index (ability to generate stable shared coherence).
+
+---
+
+## Typical workflow
+
+1. **Model** your system as a network: nodes (agents, ideas, tissues, modules) and couplings.
+2. **Select** a **trajectory of operators** aligned with your goal (e.g., *start → couple → stabilize*).
+3. **Simulate** the dynamics: number of steps, step size, tolerances.
+4. **Measure**: C(t), ΔNFR, Si; identify bifurcations and collapses.
+5. **Iterate** with controlled **dissonance** to open mutations without losing form.
+
+---
+
+## High‑level API (orientation map)
+
+> The typical module layout in `tnfr` is:
+
+* `tnfr.core`: `Node`, `Network`, `EPI`, `State`
+* `tnfr.ops`: structural operators (Emission, Reception, Coherence, Dissonance, ...)
+* `tnfr.sim`: integrators (`run`, `step`, `integrate`), dt control and thresholds
+* `tnfr.metrics`: `coherence`, `gradient`, `sense_index`, `phase_sync`
+* `tnfr.viz`: plotting utilities (`plot_coherence`, `plot_network`, `plot_phase`)
+
+Usage examples:
+
+```python
+from tnfr import core, ops, sim, metrics
+
+net = core.Network.from_edges([
+    ("n1", "n2", 0.6),
+    ("n2", "n3", 0.8),
+])
+
+sequence = [ops.Emission(0.3), ops.Coupling(0.5), ops.Coherence()]
+traj = sim.run(net, sequence, steps=500)
+
+print(metrics.coherence(traj))
+```
+
+---
+
+## Parametric modeling
+
+```python
+import tnfr as T
+
+net = T.Network.uniform(n=25, nu_f=0.4, coupling=0.3)
+plan = (
+    T.ops.Emission(0.2)
+  >> T.ops.Expansion(0.4)
+  >> T.ops.Coupling(0.6)
+  >> T.ops.Coherence()
+)
+traj = T.sim.run(net, plan, steps=800)
+T.viz.plot_phase(traj)
+```
+
+---
+
+## Main metrics
+
+* `coherence(traj) → C(t)`: global stability; higher values indicate sustained form.
+* `gradient(state) → ΔNFR`: local demand for reorganization (high = risk of collapse/bifurcation).
+* `sense_index(traj) → Si`: proxy for **structural sense** (capacity to generate shared coherence) combining **νf**, phase, and topology.
+
+---
+
+## Best practices
+
+* **Short sequences** and frequent C(t) checks avoid unnecessary collapses.
+* Use **dissonance** as a tool: introduce it to open possibilities, but **seal** with coherence.
+* **Scale first, detail later:** tune coarse couplings before micro‑parameters.
+
+---
+
+## Project status
+
+* **pre‑1.0 API**: signatures may be refined; concepts and magnitudes are stable.
+* **Pure‑Python** core with minimal dependencies (optional: `numpy`, `matplotlib`, `networkx`).
+
+---
+
+## Contributing
+
+Suggestions, issues, and PRs are welcome. Guidelines:
+
+1. Prioritize **operational clarity** (names, docstrings, examples).
+2. Add **tests** and **notebooks** that show the structural effect of each PR.
+3. Keep **semantic neutrality**: operators act on form, not on contents.
+
+---
+
+## License
+
+MIT 
+
+---
+
+## References & notes
+
+* Theoretical foundations: TNFR operational manual.
+* Operational definitions: nodal equation, dimensions (frequency, phase, form), and structural operators.
+
+> If you use `tnfr` in research or projects, please cite the TNFR conceptual framework and link to the PyPI package.

{tnfr-4.5.0 → tnfr-4.5.1}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "tnfr"
-version = "4.5.0"
-description = "Canonical TNFR: modular glyph-based dynamics on networks."
+version = "4.5.1"
+description = "modular structural-based dynamics on networks"
 readme = "README.md"
 requires-python = ">=3.9"
 license = { text = "MIT" }
@@ -40,3 +40,4 @@ build-backend = "setuptools.build_meta"
 
 
 
+

{tnfr-4.5.0 → tnfr-4.5.1}/src/tnfr/__init__.py

@@ -8,7 +8,7 @@ Ecuación nodal:
     ∂EPI/∂t = νf · ΔNFR(t)
 """
 
-__version__ = "4.5.0"
+__version__ = "4.5.1"
 
 # Re-exports de la API pública
 from .dynamics import step, run, set_delta_nfr_hook, validate_canon
@@ -87,3 +87,4 @@ __all__ = [
 ]
 
 
+

{tnfr-4.5.0 → tnfr-4.5.1}/src/tnfr/observers.py

@@ -101,9 +101,17 @@ def carga_glifica(G, window: int | None = None) -> dict:
     # Proporciones por glifo
     dist = {k: v / count for k, v in total.items()}
 
-
     # Agregados conceptuales (puedes ajustar categorías)
+    # Glifos que consolidan la coherencia nodal: I’L estabiliza el flujo (cap. 6),
+    # R’A propaga la resonancia (cap. 9), U’M acopla nodos en fase (cap. 8)
+    # y SH’A ofrece silencio regenerativo (cap. 10). Véase manual TNFR,
+    # sec. 18.19 "Análisis morfosintáctico" para la taxonomía funcional.
     estabilizadores = ["I’L", "R’A", "U’M", "SH’A"]
+
+    # Glifos que perturban o reconfiguran la red: O’Z introduce disonancia
+    # evolutiva (cap. 7), Z’HIR muta la estructura (cap. 14), NA’V marca
+    # el tránsito entre estados (cap. 15) y T’HOL autoorganiza un nuevo
+    # orden (cap. 13). Véase manual TNFR, sec. 18.19 para esta clasificación.
     disruptivos = ["O’Z", "Z’HIR", "NA’V", "T’HOL"]
 
 

tnfr-4.5.1/src/tnfr.egg-info/PKG-INFO

@@ -0,0 +1,221 @@
+Metadata-Version: 2.4
+Name: tnfr
+Version: 4.5.1
+Summary: modular structural-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,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
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: networkx>=2.6
+Dynamic: license-file
+
+# tnfr · Python package
+
+> Engine for **modeling, simulation, and measurement** of multiscale structural coherence through **structural operators** (emission, reception, coherence, dissonance, coupling, resonance, silence, expansion, contraction, self‑organization, mutation, transition, recursivity).
+
+---
+
+## What is `tnfr`?
+
+`tnfr` is a Python library to **operate with form**: build nodes, couple them into networks, and **modulate their coherence** over time using structural operators. It does not describe “things”; it **activates processes**. Its theoretical basis is the Resonant Fractal Nature Theory (TNFR), which understands reality as **networks of coherence** that persist because they **resonate**.
+
+In practical terms, `tnfr` lets you:
+
+* Model **Resonant Fractal Nodes (NFR)** with parameters for **frequency** (νf), **phase** (θ), and **form** (EPI).
+* Apply **structural operators** to start, stabilize, propagate, or reconfigure coherence.
+* **Simulate** nodal dynamics with discrete/continuous integrators.
+* **Measure** global coherence C(t), nodal gradient ΔNFR, and the **Sense Index** (Si).
+* **Visualize** states and trajectories (coupling matrices, C(t) curves, graphs).
+
+> **Nodal equation (operational core)**
+>
+> $\frac{\partial \mathrm{EPI}}{\partial t} = \nu_f\,\cdot\,\Delta\mathrm{NFR}(t)$
+>
+> A form emerges and persists when **internal reorganization** (ΔNFR) **resonates** with the node’s **frequency** (νf).
+
+---
+
+## Installation
+
+```bash
+pip install tnfr
+```
+
+Requires **Python ≥ 3.9**.
+
+---
+
+## Why TNFR (in 60 seconds)
+
+* **From objects to coherences:** you model **processes** that hold, not fixed entities.
+* **Operators instead of rules:** you compose **structural operators** (e.g., *emission*, *coherence*, *dissonance*) to **build trajectories**.
+* **Operational fractality:** the same pattern works for **ideas, teams, tissues, narratives**; the scales change, **the logic doesn’t**.
+
+---
+
+## Getting started (minimal recipe)
+
+> *The high‑level API centers on three things: nodes, operators, simulation.*
+
+```python
+# 1) Nodes and network
+import tnfr as T
+
+# A minimal set of nodes with initial frequency (νf)
+A = T.Node(label="seed", nu_f=0.8)
+B = T.Node(label="context", nu_f=0.6)
+net = T.Network([A, B], edges=[(A, B, 0.7)])  # coupling 0..1
+
+# 2) Sequence of structural operators
+ops = [
+    T.ops.Emission(strength=0.4),      # start pattern
+    T.ops.Coupling(weight=0.7),        # synchronize nodes
+    T.ops.Coherence(),                 # stabilize form
+]
+
+# 3) Simulation and metrics
+traj = T.sim.run(net, ops, steps=200, dt=0.05)
+print("C(t) =", T.metrics.coherence(traj)[-1])
+print("Si   =", T.metrics.sense_index(traj))
+
+# 4) Quick visualization
+T.viz.plot_coherence(traj)     # C(t) curve
+T.viz.plot_network(net)        # graph/couplings
+```
+
+> **Note:** Specific class/function names may vary across minor versions. Check `help(T.ops)` and `help(T.sim)` for your installed API.
+
+---
+
+## Key concepts (operational summary)
+
+* **Node (NFR):** a unit that persists because it **resonates**. Parameterized by **νf** (frequency), **θ** (phase), and **EPI** (coherent form).
+* **Structural operators:** functions that reorganize the network. We use **functional** names (not phonemes):
+
+  * **Emission** (start), **Reception** (open), **Coherence** (stabilize), **Dissonance** (creative tension), **Coupling** (synchrony), **Resonance** (propagate), **Silence** (latency), **Expansion**, **Contraction**, **Self‑organization**, **Mutation**, **Transition**, **Recursivity**.
+* **Magnitudes:**
+
+  * **C(t):** global coherence.
+  * **ΔNFR:** nodal gradient (need for reorganization).
+  * **νf:** structural frequency (Hz\_str).
+  * **Si:** sense index (ability to generate stable shared coherence).
+
+---
+
+## Typical workflow
+
+1. **Model** your system as a network: nodes (agents, ideas, tissues, modules) and couplings.
+2. **Select** a **trajectory of operators** aligned with your goal (e.g., *start → couple → stabilize*).
+3. **Simulate** the dynamics: number of steps, step size, tolerances.
+4. **Measure**: C(t), ΔNFR, Si; identify bifurcations and collapses.
+5. **Iterate** with controlled **dissonance** to open mutations without losing form.
+
+---
+
+## High‑level API (orientation map)
+
+> The typical module layout in `tnfr` is:
+
+* `tnfr.core`: `Node`, `Network`, `EPI`, `State`
+* `tnfr.ops`: structural operators (Emission, Reception, Coherence, Dissonance, ...)
+* `tnfr.sim`: integrators (`run`, `step`, `integrate`), dt control and thresholds
+* `tnfr.metrics`: `coherence`, `gradient`, `sense_index`, `phase_sync`
+* `tnfr.viz`: plotting utilities (`plot_coherence`, `plot_network`, `plot_phase`)
+
+Usage examples:
+
+```python
+from tnfr import core, ops, sim, metrics
+
+net = core.Network.from_edges([
+    ("n1", "n2", 0.6),
+    ("n2", "n3", 0.8),
+])
+
+sequence = [ops.Emission(0.3), ops.Coupling(0.5), ops.Coherence()]
+traj = sim.run(net, sequence, steps=500)
+
+print(metrics.coherence(traj))
+```
+
+---
+
+## Parametric modeling
+
+```python
+import tnfr as T
+
+net = T.Network.uniform(n=25, nu_f=0.4, coupling=0.3)
+plan = (
+    T.ops.Emission(0.2)
+  >> T.ops.Expansion(0.4)
+  >> T.ops.Coupling(0.6)
+  >> T.ops.Coherence()
+)
+traj = T.sim.run(net, plan, steps=800)
+T.viz.plot_phase(traj)
+```
+
+---
+
+## Main metrics
+
+* `coherence(traj) → C(t)`: global stability; higher values indicate sustained form.
+* `gradient(state) → ΔNFR`: local demand for reorganization (high = risk of collapse/bifurcation).
+* `sense_index(traj) → Si`: proxy for **structural sense** (capacity to generate shared coherence) combining **νf**, phase, and topology.
+
+---
+
+## Best practices
+
+* **Short sequences** and frequent C(t) checks avoid unnecessary collapses.
+* Use **dissonance** as a tool: introduce it to open possibilities, but **seal** with coherence.
+* **Scale first, detail later:** tune coarse couplings before micro‑parameters.
+
+---
+
+## Project status
+
+* **pre‑1.0 API**: signatures may be refined; concepts and magnitudes are stable.
+* **Pure‑Python** core with minimal dependencies (optional: `numpy`, `matplotlib`, `networkx`).
+
+---
+
+## Contributing
+
+Suggestions, issues, and PRs are welcome. Guidelines:
+
+1. Prioritize **operational clarity** (names, docstrings, examples).
+2. Add **tests** and **notebooks** that show the structural effect of each PR.
+3. Keep **semantic neutrality**: operators act on form, not on contents.
+
+---
+
+## License
+
+MIT 
+
+---
+
+## References & notes
+
+* Theoretical foundations: TNFR operational manual.
+* Operational definitions: nodal equation, dimensions (frequency, phase, form), and structural operators.
+
+> If you use `tnfr` in research or projects, please cite the TNFR conceptual framework and link to the PyPI package.

tnfr-4.5.0/PKG-INFO

@@ -1,109 +0,0 @@
-Metadata-Version: 2.4
-Name: tnfr
-Version: 4.5.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,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
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Intended Audience :: Science/Research
-Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
-Classifier: Topic :: Scientific/Engineering :: Information Analysis
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-License-File: LICENSE.md
-Requires-Dist: networkx>=2.6
-Dynamic: license-file
-
-# TNFR Python Project
-
-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.
-
-* **Configuration & constants.** `constants.py` centralizes default parameters (discretization, EPI and νf ranges, mixing weights, re-mesh limits, etc.) and provides utilities to inject them into the network (`attach_defaults`, `merge_overrides`), along with standardized aliases for node attributes.
-
-* **Cross-cutting utilities.** `helpers.py` offers core numeric helpers, alias-based attribute accessors, neighborhood statistics, glyph history, a callback system, and computation of the sense index `Si` for each node.
-
-* **Dynamics engine.** `dynamics.py` implements the simulation loop: ΔNFR field computation, nodal equation integration, glyph selection/application, clamps, phase coordination, history updates, and conditional re-mesh (`step` and `run`).
-
-* **Glyph operators.** `operators.py` defines the 13 glyphs as local transformations, a dispatcher `aplicar_glifo`, and both direct and stability-conditioned re-mesh utilities.
-
-* **Observers & metrics.** `observers.py` registers standard callbacks and computes global coherence, phase synchrony, Kuramoto order, glyph distribution, and the sense vector `Σ⃗`, among others.
-
-* **Simulation orchestration.** `ontosim.py` prepares a NetworkX graph, attaches configuration, and initializes attributes (EPI, phases, frequencies) before delegating dynamics to `dynamics.step`/`run`.
-
-* **Demo CLI.** `main.py` generates an Erdős–Rényi network, lets you tweak basic parameters, and runs the simulation while displaying final metrics.
-
----
-
-## Key Concepts to Grasp
-
-* **Aliased dependency tree.** Modules import each other via global aliases to simplify access and prevent cycles—essential for navigating the code unambiguously.
-
-* **Normalized node attributes.** All data (EPI, phase `θ`, frequency `νf`, `ΔNFR`, etc.) live in `G.nodes[n]` under compatible alias names, making extensions and custom hooks straightforward.
-
-* **Sense Index (`Si`).** Combines normalized frequency, phase dispersion, and field magnitude to evaluate each node’s “sense,” influencing glyph selection.
-
-* **Step-wise engine.** `dynamics.step` orchestrates eight phases: field computation, `Si`, glyph selection & application, integration, clamps, phase coordination, history update, and conditioned re-mesh.
-
-* **Glyphs as operators.** Each glyph applies a smooth transformation to node attributes (emission, diffusion, coupling, dissonance, etc.), dispatched by a configurable, typographic name.
-
-* **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.
-
----
-
-## Recommendations for Going Deeper
-
-* **NetworkX & the Graph API.** Get comfortable with how NetworkX handles attributes and topology; all dynamics operate on `Graph` objects and their properties.
-
-* **Extending the ΔNFR field.** Explore `set_delta_nfr_hook` to implement alternative nodal fields and learn how metadata and mixing weights are recorded.
-
-* **Designing new glyphs.** Review `operators.py` to add operators or adjust factors in `DEFAULTS['GLYPH_FACTORS']`.
-
-* **Custom observers.** Implement your own metrics via `register_callback` or by extending `observers.py` to measure phenomena specific to your study.
-
-* **Theoretical reading.** For conceptual background, see the included PDFs (`TNFR.pdf`, *El Pulso que nos Atraviesa*), which deepen the fractal-resonant framework.
-
-* **Advanced parameters.** Experiment with adaptive phase coordination, stability criteria, and the glyph grammar to observe their impact on network self-organization.
-
----
-
-**Mastering these pieces will let you extend the simulation, build analysis pipelines and connect the theory with computational applications.**
-
-## Optional Node environment
-The repository includes a minimal `package.json` and `netlify.toml` used for an experimental Remix web demo. They are not required for the core Python package; feel free to ignore them unless you plan to build the demo via `npm run build`.
-
-## Testing
-
-Install the dependencies and project in editable mode before running the test suite with `pytest`:
-
-```
-pip install networkx
-pip install -e .
-pytest
-
-```
-
-## Installation
-```
-pip install tnfr
-```

tnfr-4.5.0/README.md

@@ -1,82 +0,0 @@
-# TNFR Python Project
-
-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.
-
-* **Configuration & constants.** `constants.py` centralizes default parameters (discretization, EPI and νf ranges, mixing weights, re-mesh limits, etc.) and provides utilities to inject them into the network (`attach_defaults`, `merge_overrides`), along with standardized aliases for node attributes.
-
-* **Cross-cutting utilities.** `helpers.py` offers core numeric helpers, alias-based attribute accessors, neighborhood statistics, glyph history, a callback system, and computation of the sense index `Si` for each node.
-
-* **Dynamics engine.** `dynamics.py` implements the simulation loop: ΔNFR field computation, nodal equation integration, glyph selection/application, clamps, phase coordination, history updates, and conditional re-mesh (`step` and `run`).
-
-* **Glyph operators.** `operators.py` defines the 13 glyphs as local transformations, a dispatcher `aplicar_glifo`, and both direct and stability-conditioned re-mesh utilities.
-
-* **Observers & metrics.** `observers.py` registers standard callbacks and computes global coherence, phase synchrony, Kuramoto order, glyph distribution, and the sense vector `Σ⃗`, among others.
-
-* **Simulation orchestration.** `ontosim.py` prepares a NetworkX graph, attaches configuration, and initializes attributes (EPI, phases, frequencies) before delegating dynamics to `dynamics.step`/`run`.
-
-* **Demo CLI.** `main.py` generates an Erdős–Rényi network, lets you tweak basic parameters, and runs the simulation while displaying final metrics.
-
----
-
-## Key Concepts to Grasp
-
-* **Aliased dependency tree.** Modules import each other via global aliases to simplify access and prevent cycles—essential for navigating the code unambiguously.
-
-* **Normalized node attributes.** All data (EPI, phase `θ`, frequency `νf`, `ΔNFR`, etc.) live in `G.nodes[n]` under compatible alias names, making extensions and custom hooks straightforward.
-
-* **Sense Index (`Si`).** Combines normalized frequency, phase dispersion, and field magnitude to evaluate each node’s “sense,” influencing glyph selection.
-
-* **Step-wise engine.** `dynamics.step` orchestrates eight phases: field computation, `Si`, glyph selection & application, integration, clamps, phase coordination, history update, and conditioned re-mesh.
-
-* **Glyphs as operators.** Each glyph applies a smooth transformation to node attributes (emission, diffusion, coupling, dissonance, etc.), dispatched by a configurable, typographic name.
-
-* **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.
-
----
-
-## Recommendations for Going Deeper
-
-* **NetworkX & the Graph API.** Get comfortable with how NetworkX handles attributes and topology; all dynamics operate on `Graph` objects and their properties.
-
-* **Extending the ΔNFR field.** Explore `set_delta_nfr_hook` to implement alternative nodal fields and learn how metadata and mixing weights are recorded.
-
-* **Designing new glyphs.** Review `operators.py` to add operators or adjust factors in `DEFAULTS['GLYPH_FACTORS']`.
-
-* **Custom observers.** Implement your own metrics via `register_callback` or by extending `observers.py` to measure phenomena specific to your study.
-
-* **Theoretical reading.** For conceptual background, see the included PDFs (`TNFR.pdf`, *El Pulso que nos Atraviesa*), which deepen the fractal-resonant framework.
-
-* **Advanced parameters.** Experiment with adaptive phase coordination, stability criteria, and the glyph grammar to observe their impact on network self-organization.
-
----
-
-**Mastering these pieces will let you extend the simulation, build analysis pipelines and connect the theory with computational applications.**
-
-## Optional Node environment
-The repository includes a minimal `package.json` and `netlify.toml` used for an experimental Remix web demo. They are not required for the core Python package; feel free to ignore them unless you plan to build the demo via `npm run build`.
-
-## Testing
-
-Install the dependencies and project in editable mode before running the test suite with `pytest`:
-
-```
-pip install networkx
-pip install -e .
-pytest
-
-```
-
-## Installation
-```
-pip install tnfr
-```

tnfr-4.5.0/src/tnfr.egg-info/PKG-INFO

@@ -1,109 +0,0 @@
-Metadata-Version: 2.4
-Name: tnfr
-Version: 4.5.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,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
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Intended Audience :: Science/Research
-Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
-Classifier: Topic :: Scientific/Engineering :: Information Analysis
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-License-File: LICENSE.md
-Requires-Dist: networkx>=2.6
-Dynamic: license-file
-
-# TNFR Python Project
-
-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.
-
-* **Configuration & constants.** `constants.py` centralizes default parameters (discretization, EPI and νf ranges, mixing weights, re-mesh limits, etc.) and provides utilities to inject them into the network (`attach_defaults`, `merge_overrides`), along with standardized aliases for node attributes.
-
-* **Cross-cutting utilities.** `helpers.py` offers core numeric helpers, alias-based attribute accessors, neighborhood statistics, glyph history, a callback system, and computation of the sense index `Si` for each node.
-
-* **Dynamics engine.** `dynamics.py` implements the simulation loop: ΔNFR field computation, nodal equation integration, glyph selection/application, clamps, phase coordination, history updates, and conditional re-mesh (`step` and `run`).
-
-* **Glyph operators.** `operators.py` defines the 13 glyphs as local transformations, a dispatcher `aplicar_glifo`, and both direct and stability-conditioned re-mesh utilities.
-
-* **Observers & metrics.** `observers.py` registers standard callbacks and computes global coherence, phase synchrony, Kuramoto order, glyph distribution, and the sense vector `Σ⃗`, among others.
-
-* **Simulation orchestration.** `ontosim.py` prepares a NetworkX graph, attaches configuration, and initializes attributes (EPI, phases, frequencies) before delegating dynamics to `dynamics.step`/`run`.
-
-* **Demo CLI.** `main.py` generates an Erdős–Rényi network, lets you tweak basic parameters, and runs the simulation while displaying final metrics.
-
----
-
-## Key Concepts to Grasp
-
-* **Aliased dependency tree.** Modules import each other via global aliases to simplify access and prevent cycles—essential for navigating the code unambiguously.
-
-* **Normalized node attributes.** All data (EPI, phase `θ`, frequency `νf`, `ΔNFR`, etc.) live in `G.nodes[n]` under compatible alias names, making extensions and custom hooks straightforward.
-
-* **Sense Index (`Si`).** Combines normalized frequency, phase dispersion, and field magnitude to evaluate each node’s “sense,” influencing glyph selection.
-
-* **Step-wise engine.** `dynamics.step` orchestrates eight phases: field computation, `Si`, glyph selection & application, integration, clamps, phase coordination, history update, and conditioned re-mesh.
-
-* **Glyphs as operators.** Each glyph applies a smooth transformation to node attributes (emission, diffusion, coupling, dissonance, etc.), dispatched by a configurable, typographic name.
-
-* **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.
-
----
-
-## Recommendations for Going Deeper
-
-* **NetworkX & the Graph API.** Get comfortable with how NetworkX handles attributes and topology; all dynamics operate on `Graph` objects and their properties.
-
-* **Extending the ΔNFR field.** Explore `set_delta_nfr_hook` to implement alternative nodal fields and learn how metadata and mixing weights are recorded.
-
-* **Designing new glyphs.** Review `operators.py` to add operators or adjust factors in `DEFAULTS['GLYPH_FACTORS']`.
-
-* **Custom observers.** Implement your own metrics via `register_callback` or by extending `observers.py` to measure phenomena specific to your study.
-
-* **Theoretical reading.** For conceptual background, see the included PDFs (`TNFR.pdf`, *El Pulso que nos Atraviesa*), which deepen the fractal-resonant framework.
-
-* **Advanced parameters.** Experiment with adaptive phase coordination, stability criteria, and the glyph grammar to observe their impact on network self-organization.
-
----
-
-**Mastering these pieces will let you extend the simulation, build analysis pipelines and connect the theory with computational applications.**
-
-## Optional Node environment
-The repository includes a minimal `package.json` and `netlify.toml` used for an experimental Remix web demo. They are not required for the core Python package; feel free to ignore them unless you plan to build the demo via `npm run build`.
-
-## Testing
-
-Install the dependencies and project in editable mode before running the test suite with `pytest`:
-
-```
-pip install networkx
-pip install -e .
-pytest
-
-```
-
-## Installation
-```
-pip install tnfr
-```