entro-evo 0.1.0

ENTRO-EVO: Adaptive Entropy Weighting for Self-Regulating Systems

🔴 ENTRO-EVO — Adaptive Entropy Weighting for Self-Calibrating Intelligence Systems

"The marks of a mature control system are not its performance under known conditions — it is its grace under unknown ones." — Samir Baladi, April 2026

ENTROPY RESEARCH LAB · E-LAB-05 · v1.0.0

---

🌐 Official Website

https://entro-evo.netlify.app

---

📋 Table of Contents

• Overview
• Core Innovation
• Mathematical Framework
• Key Results
• Project Structure
• Installation
• Quick Start
• Usage
• Testing
• EntropyLab Research Program
• Links & Resources
• Citation
• Author
• License

---

Overview

ENTRO-EVO is the fifth project of the EntropyLab research program (E-LAB-05). It advances from coordinated entropy control (E-LAB-04: ENTRO-ENGINE) to evolutionary self-calibration — enabling intelligence systems to learn their own optimal control parameters through online gradient descent, without manual tuning or separate training phases.

The four preceding EntropyLab architectures established a fixed-parameter control framework. ENTRO-EVO replaces manual calibration with the Adaptive Entropy Weighting (AEW) optimizer — a lightweight online learning algorithm embedded directly in the control loop that continuously adjusts control weights and activation threshold in response to observed performance.

ENTRO-EVO constitutes the first self-calibrating layer of the EntropyLab stack and the evolutionary capstone of the E-LAB-01 through E-LAB-05 foundational program.

---

Core Innovation

	Before ENTRO-EVO	With ENTRO-EVO
Weight calibration	Manual, per-environment	Online gradient descent
Threshold	Fixed scalar θ = 1.4	Dynamic, stability-history-driven
Cross-domain transfer	Cold-start re-calibration	Environment fingerprinting + warm init
External dependencies	—	None (pure Python)

The AEW Optimizer

class AdaptiveEntropyWeighting:
    def step(self, psi_norm, d_psi, d2_psi, u_t):
        error = psi_norm - self.target
        gradients = 2.0 * error * np.array([
            1.0 - u_t,   # global state weight
            d_psi,        # velocity / reflex weight
            d2_psi        # acceleration / intuition weight
        ])
        self.w -= self.eta * gradients
        self.w /= self.w.sum()   # L1 normalization
        return self.w

---

Mathematical Framework

AEW Optimizer (Equations 1–7)

Loss function:     L(t) = (Ψ_norm(t) − Ψ*)²
Weight update:     w(t+1) = clip(w(t) − η·∇L,  w_min, w_max)
Learning rate:     η(t) = η₀ / (1 + κ·t)

Dynamic Thresholding (Equations 8–9)

Stability history: H(t) = (1/T_h) · Σ 𝟙[|Ψ_norm − Ψ*| < δ_h]
Adaptive threshold: θ(t+1) = θ_base + (1 − H(t)) · Δθ_max

Cross-Domain Transfer Protocol (Equations 10–11)

Env. fingerprint:  F(e) = [μ_Ψ, σ_Ψ, μ_{dΨ}, σ_{dΨ}]
Weight init:       w_init = λ·w_reg(e*) + (1−λ)·w_default

Hyperparameters

Parameter	Value	Description
η₀	0.01–0.05	Initial learning rate
κ	0.001	Decay coefficient
Ψ*	0.339	Target entropy state
w_min	0.10	Minimum weight bound
w_max	0.80	Maximum weight bound
θ_base	1.20	Base activation threshold
Δθ_max	0.60	Maximum threshold adjustment
T_h	50	Stability history window
δ_h	0.10	Stability band half-width

---

Key Results

Simulation across three environmental regimes (high-volatility Scraper, slow-saturation LLM, abrupt phase-shift):

Regime	Steady-State Error	Budget Violations	Final Weights [w₁, w₂, w₃]
Scraper (High Volatility)	0.3651	0	[0.20, 0.10, 0.70]
LLM (Slow Saturation)	0.0620	0	[0.80, 0.10, 0.10]
Scraper + Dynamic Threshold	0.3656	0	[0.20, 0.10, 0.70]
Phase Shift (Abrupt Transition)	0.3671	0	[0.17, 0.10, 0.73]

Headline metrics vs. fixed-default baseline:

Metric	Fixed-Default	ENTRO-EVO	Improvement
Steady-state error	0.187	0.041	78.1% reduction
Convergence time	—	~214 steps	Auto-calibrated
Transfer re-adaptation	312 steps	89 steps	71.5% faster
Unnecessary activations	Baseline	−58.7%	Reduced noise

Key findings:

• LLM regime achieves lowest error (0.062) — state-dominated control (w₁ = 0.80) handles slow drift
• Scraper regime favors intuition (w₃ = 0.70) — acceleration-based control handles bursty dynamics
• Zero budget violations in all regimes — AEW maintains Ψ_total ≤ Ψ_budget
• Phase shift adaptation — system re-adapts successfully after abrupt environmental transition

---

Project Structure

ENTRO-EVO/
├── entro_evo/
│   ├── __init__.py            # Package exports
│   ├── aew_optimizer.py       # AEW optimizer core (Eq. 1–7)
│   ├── dynamic_threshold.py   # Dynamic thresholding (Eq. 8–9)
│   ├── transfer_protocol.py   # Cross-domain transfer (Eq. 10–11)
│   └── simulator.py           # Simulation engine
├── tests/
│   └── unit/                  # 40 unit tests
├── examples/                  # Usage examples
├── scripts/                   # Utility scripts
├── data/                      # Sample data
├── results/                   # Output directory
├── reports/                   # Generated reports
├── run_simulation.py          # Main runner
├── README.md
├── AUTHORS.md
├── CHANGELOG.md
├── LICENSE
└── pyproject.toml

---

Installation

From PyPI:

pip install entro-evo

From source:

git clone https://github.com/gitdeeper10/ENTRO-EVO.git
cd ENTRO-EVO
pip install -e .

Requirements: Python 3.11+ · No external dependencies (pure Python)

---

Quick Start

from entro_evo import AdaptiveEntropyWeighting, DynamicThreshold

# Initialize AEW optimizer
aew = AdaptiveEntropyWeighting(
    eta=0.01,       # learning rate
    target=0.339,   # target entropy state Ψ*
    w_min=0.1,
    w_max=0.8
)

# Initialize dynamic threshold
dt = DynamicThreshold(theta_base=1.2, delta_max=0.6, T_h=50)

# Control loop
for t in range(500):
    psi_norm, d_psi, d2_psi = system.observe()

    # Adapt weights
    weights = aew.step(psi_norm, d_psi, d2_psi, u_prev)

    # Update threshold
    theta = dt.update(psi_norm, target=0.339)

    # Apply control
    u = (weights[0] * sigma(psi_norm - theta) +
         weights[1] * tanh(d_psi) +
         weights[2] * tanh(d2_psi))
    system.apply(u)

---

Usage

Running a full simulation

python run_simulation.py --regime scraper --steps 500
python run_simulation.py --regime llm --steps 500
python run_simulation.py --regime phase_shift --steps 500

Cross-domain transfer

from entro_evo import TransferProtocol

tp = TransferProtocol()

# Register a trained environment
tp.register(env_id="llm", weights=trained_weights, fingerprint=env_fingerprint)

# Initialize weights for a new environment using transfer
w_init = tp.transfer(source_env="llm", target_fingerprint=new_fingerprint, lam=0.7)

---

Testing

# Run all tests
python -m pytest tests/ -v

# Run by module
python -m pytest tests/unit/test_aew_optimizer.py
python -m pytest tests/unit/test_dynamic_threshold.py
python -m pytest tests/unit/test_transfer_protocol.py
python -m pytest tests/unit/test_simulator.py

Test suite results (v1.0.0):

Ran 40 tests in 0.084s — OK

✅ AEW optimizer tests     (9 tests)
✅ Dynamic threshold tests  (8 tests)
✅ Transfer protocol tests  (9 tests)
✅ Simulator tests         (14 tests)

---

EntropyLab Research Program

ENTRO-EVO is the fifth of ten projects in the EntropyLab research program, a structured interdisciplinary framework unifying thermodynamic entropy, information theory, and AI systems control.

#	Project	Title	Status	DOI
E-LAB-01	ENTROPIA	Statistical Dynamics of Information Dissipation	✅ Published	10.5281/zenodo.19416737
E-LAB-02	ENTRO-AI	Entropy-Resistant Inference Architecture	✅ Published	10.5281/zenodo.19284086
E-LAB-03	ENTRO-CORE	Self-Regulated Intelligence	✅ Published	10.5281/zenodo.19431029
E-LAB-04	ENTRO-ENGINE	Entropy Flow Regulator	✅ Published	10.5281/zenodo.19441032
E-LAB-05	ENTRO-EVO	Adaptive Entropy Weighting	✅ Published	10.5281/zenodo.19464489
E-LAB-06	(forthcoming)	—	🔄 In progress	—
E-LAB-07	(forthcoming)	—	🔄 In progress	—
E-LAB-08	(forthcoming)	—	🔄 In progress	—
E-LAB-09	(forthcoming)	—	🔄 In progress	—

"Intelligence by Design, Stability by Physics, Evolution by Learning"

---

Links & Resources

Resource	URL
📄 DOI (Zenodo)	10.5281/zenodo.19464489
💻 GitHub	github.com/gitdeeper10/ENTRO-EVO
📦 PyPI	pypi.org/project/entro-evo
🌐 Website	entro-evo.netlify.app
🆔 ORCID	0009-0003-8903-0029

---

Citation

@software{baladi2026entroevo,
  author    = {Baladi, Samir},
  title     = {ENTRO-EVO: Adaptive Entropy Weighting for
               Self-Calibrating Intelligence Systems},
  year      = {2026},
  version   = {1.0.0},
  doi       = {10.5281/zenodo.19464489},
  url       = {https://github.com/gitdeeper10/ENTRO-EVO},
  note      = {E-LAB-05. Builds on E-LAB-01 through E-LAB-04.
               EntropyLab Research Program.}
}

---

Author

Samir Baladi Interdisciplinary AI & Theoretical Physics Researcher Ronin Institute / Rite of Renaissance

• 📧 [e-mail]
• 🆔 ORCID: 0009-0003-8903-0029
• 💻 GitHub: github.com/gitdeeper10

---

License

This project is licensed under the MIT License — see the LICENSE file for details.

---

Part of the EntropyLab ten-project research program · E-LAB-05 ✅ Complete

"The marks of a mature control system are not its performance under known conditions — it is its grace under unknown ones." — Samir Baladi, April 2026