🔴 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
📋 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
- 📧 gitdeeper@gmail.com
- 🆔 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
Metadata
Release files for entro-evo 0.1.0
For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.
Source distribution (sdist)
| File | Size | Uploaded | Provenance | Actions |
|---|---|---|---|---|
| entro_evo-0.1.0.tar.gz | 36.7 kB | Without provenance | Details for entro_evo-0.1.0.tar.gz |
Built distribution (wheel)
| File | Interpreter | ABI | Platform | Actions Reset |
|---|---|---|---|---|
| entro_evo-0.1.0-py3-none-any.whl | Python 3 | none | any | Details for entro_evo-0.1.0-py3-none-any.whl |
Total release size: 54.2 kB
Release files / entro_evo-0.1.0.tar.gz
| Download URL | entro_evo-0.1.0.tar.gz |
|---|---|
| Size | 36.7 kB |
| Tags | Source |
|
SHA-256 checksum How to use checksums |
4cdbc080e0a891f6556601e2f5595e65975b2174ca5f9f0d7988016d1e942c9c
|
|
BLAKE2b-256 checksum How to use checksums |
996e54eb20afb171c3957624e1722cf2d352dadf32c39c4a336bd16ca5741b00
|
| Upload date | |
|
Uploaded using Trusted Publishing? What is trusted publishing? |
No |
| Uploaded via |
ENTRO-EVO-Uploader/0.1.0
|
Release files / entro_evo-0.1.0-py3-none-any.whl
| Download URL | entro_evo-0.1.0-py3-none-any.whl |
|---|---|
| Size | 17.5 kB |
| Tags | Python 3 |
|
SHA-256 checksum How to use checksums |
af50921cad955d2c5ef8e3fc32273a668582070fcb2d2a7699c31747e3155d29
|
|
BLAKE2b-256 checksum How to use checksums |
3bd6029caf4bbd9cd3a0881b0584c74b16d69f5b3ccf1bdaace75b0386d53a0c
|
| Upload date | |
|
Uploaded using Trusted Publishing? What is trusted publishing? |
No |
| Uploaded via |
ENTRO-EVO-Uploader/0.1.0
|
Security for entro-evo 0.1.0
Provenance
Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.
No provenance found
None of the files in this release were uploaded with provenance metadata.
A note on package security
PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.
To learn more about protecting yourself from malicious actors, visit our package security documentation.