Resonant Fractal Nature Theory (TNFR)

The TNFR paradigm describes reality as networks of coherence that persist because they resonate. This site distills its operational principles and shows how the tnfr Python package renders them faithfully for research and instrumentation.

Paradigm essence

TNFR does not model static “things”. It formalizes coherences that stay active in nodes when their structural frequency (νf · Hzstr) synchronizes with the internal reorganization (ΔNFR) and with the network phase. The canonical nodal equation states that the evolution of the Primary Information Structure (EPI) follows the pulse of that resonance:

∂EPI / ∂t = νf · ΔNFR(t)

Structural triad

  • Frequency (νf): rate of reorganization expressed strictly in Hzstr.
  • Phase (φ): synchrony with coupled nodes; no coupling is valid without an explicit phase check.
  • Form (EPI): coherent configuration that can nest sub-EPIs without losing identity.

Structural operators

Every legitimate transformation uses the TNFR grammar of 13 structural operators: Emission, Reception, Coherence, Dissonance, Coupling, Resonance, Silence, Expansion, Contraction, Self-organization, Mutation, Transition, and Recursivity. Their compositions maintain structural closure and preserve operational fractality across scales.

These constraints make TNFR a rigorous framework for studying networks. Each node maintains a traceable history of the operators applied, the resulting ΔNFR fluctuations, and the local phase alignment, letting researchers examine how coherence propagates, bifurcates, or collapses in layered systems ranging from biological networks to computational infrastructures.

The paradigm enforces invariants: the EPI only changes through structural operators, ΔNFR is never interpreted as a classical error term, node birth and collapse follow explicit thresholds, and every simulation must remain reproducible with logged phase, νf, C(t), and Si. These guidelines uphold canonical fidelity whenever TNFR is brought into analytic or experimental environments.

The tnfr Python package

The tnfr package provides tools to create resonant nodes, apply structural operators, and measure the evolution of global coherence. It is published on PyPI and targets Python 3.9 or later.

Core capabilities

  • Construction of nodes with νf, phase, and initial form using create_nfr.
  • Execution of canonical sequences via run_sequence or dynamic integrators.
  • Standard telemetry: C(t), ΔNFR, Si, and detailed logs of structural operators applied per node.
  • Exportable traces that document multi-level evolution without breaking fractality.
  • Official CLI commands (for example, tnfr sequence) that enforce the same grammar guarantees.

Installation and extras

pip install tnfr
pip install "tnfr[numpy,yaml,orjson]"  # optional extras

The engine includes an optional import system with a shared cache and structured locking via tnfr.cached_import, keeping shared resources coherent without blocking the simulation pipeline.

Instrumentation for network studies

Because the package exposes phase-aware telemetry, researchers can reconstruct how coherence moves through complex networks. Per-node Si scores highlight which regions sustain sense-making, while ΔNFR trajectories show where reorganizations accelerate or stall. Operator histories make it straightforward to audit transitions, bifurcations, and silences, turning raw execution traces into analyzable network narratives.

Minimal example

from tnfr import create_nfr, run_sequence
from tnfr.structural import Emision, Recepcion, Coherencia, Resonancia, Silencio
from tnfr.metrics.common import compute_coherence
from tnfr.metrics.sense_index import compute_Si

G, node = create_nfr("A", epi=0.2, vf=1.0, theta=0.0)
ops = [Emision(), Recepcion(), Coherencia(), Resonancia(), Silencio()]
run_sequence(G, node, ops)

C, mean_delta_nfr, mean_depi = compute_coherence(G, return_means=True)
si_per_node = compute_Si(G)
print(f"C(t)={C:.3f}, ΔNFR̄={mean_delta_nfr:.3f}, dEPI/dt̄={mean_depi:.3f}, Si={si_per_node[node]:.3f}")

This sequence respects the nodal equation: the graph recomputes ΔNFR after each structural operator without altering the phase unless an operator specifies it, ensuring consistency with the dynamic coordinators. The metrics expose when controlled bifurcations emerge and whether the global structure maintains the required coherence.

Canonical conditions

To be recognized as TNFR, an implementation must preserve the operational invariants described in the official documentation and in AGENTS.md. The most relevant for experimentation with the engine are:

The engine exposes metrics that sustain these conditions: C(t) for total coherence, Si as the sense index, phase and νf logs, and a per-node record of structural operators. These logs make it possible to audit node births, bifurcations, and collapses with explicit criteria, keeping network analyses grounded in TNFR semantics.

How to go deeper

  1. Read the foundational document TNFR.pdf for a full explanation of the theory.
  2. Explore the examples and notes in documentation.txt and the public repository.
  3. Run ./scripts/run_tests.sh to validate that any modification respects the operational contracts.
  4. Monitor the standard metrics while designing sequences: C(t), ΔNFR, Si, phase, and νf.

TNFR is trans-scale and trans-domain: the same scaffolding describes biological, social, or computational phenomena as long as the grammar of resonant coherence is respected.