Metadata-Version: 2.4
Name: entro-dasa
Version: 10.2.0
Summary: ENTRO-DASA: Dynamic Autonomous Sovereignty Algorithm — A Cybernetic Framework for Multi-Trajectory Attractor Guidance and Self-Regulating Consistency Locks in Dissipative Cognition Systems
Author-email: Samir Baladi <gitdeeper@gmail.com>
License: MIT
Project-URL: Homepage, https://entro-dasa.netlify.app
Project-URL: Dashboard, https://entro-dasa.netlify.app/dashboard
Project-URL: Documentation, https://entro-dasa.netlify.app/documentation
Project-URL: Repository, https://github.com/gitdeeper12/ENTRO-DASA
Project-URL: GitLab, https://gitlab.com/gitdeeper12/ENTRO-DASA
Project-URL: PyPI, https://pypi.org/project/entro-dasa
Project-URL: DOI, https://doi.org/10.5281/zenodo.20353988
Classifier: Development Status :: 5 - Production/Stable
Classifier: Intended Audience :: Science/Research
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
Classifier: Topic :: Scientific/Engineering :: Mathematics
Classifier: Topic :: Scientific/Engineering :: Physics
Requires-Python: >=3.11
Description-Content-Type: text/markdown
License-File: LICENSE
License-File: NOTICE
License-File: AUTHORS.md
Requires-Dist: numpy>=2.0.0
Requires-Dist: scipy>=1.14.0
Requires-Dist: streamlit>=1.35.0
Requires-Dist: plotly>=5.24.0
Provides-Extra: dev
Requires-Dist: pytest>=7.0.0; extra == "dev"
Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
Requires-Dist: black>=22.0.0; extra == "dev"
Requires-Dist: isort>=5.12.0; extra == "dev"
Provides-Extra: viz
Requires-Dist: streamlit>=1.35.0; extra == "viz"
Requires-Dist: plotly>=5.24.0; extra == "viz"
Dynamic: license-file

<div align="center">

# ENTRO-DASA

### Dynamic Autonomous Sovereignty Algorithm

**A Cybernetic Framework for Multi-Trajectory Attractor Guidance and Self-Regulating Consistency Locks in Dissipative Cognition Systems**

---

[![PyPI version](https://img.shields.io/pypi/v/entro-dasa?color=0B1F3A&label=PyPI&logo=pypi&logoColor=white)](https://pypi.org/project/entro-dasa)
[![PyPI downloads](https://img.shields.io/pypi/dm/entro-dasa?color=1A5FC8&label=Downloads&logo=pypi&logoColor=white)](https://pypi.org/project/entro-dasa/#files)
[![Python versions](https://img.shields.io/pypi/pyversions/entro-dasa?color=306998&logo=python&logoColor=white)](https://pypi.org/project/entro-dasa)
[![DOI](https://img.shields.io/badge/DOI-10.5281%2Fzenodo.20353988-blue.svg)](https://doi.org/10.5281/zenodo.20353988)
[![OSF Preregistration](https://img.shields.io/badge/OSF-Preregistered-blue?logo=osf&logoColor=white)](https://doi.org/10.17605/OSF.IO/XXXXX)
[![ORCID](https://img.shields.io/badge/ORCID-0009--0003--8903--0029-A6CE39?logo=orcid&logoColor=white)](https://orcid.org/0009-0003-8903-0029)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![Series](https://img.shields.io/badge/Series-E--LAB--12-red)](https://osf.io/xxxxx)
[![Version](https://img.shields.io/badge/Version-10.2.0-orange)](https://github.com/gitdeeper12/ENTRO-DASA)
[![Website](https://img.shields.io/badge/Website-Live-brightgreen?logo=netlify)](https://entro-dasa.netlify.app)

</div>

---

## 📌 Overview

**ENTRO-DASA** is a deterministic, multi-threaded, real-time cybernetic framework that treats **cognitive coherence as an engineered invariant** enforced through sovereign attractor dynamics — not an emergent statistical property.

> *"Computational sovereignty is not assumed or hoped for — it is mathematically enforced through dynamic attractor governance and adaptive gravity modulation."*

Contemporary AI architectures operating as open dissipative systems exhibit characteristic failure modes under environmental noise: contextual drift, semantic divergence, inference trajectory collapse, and stochastic resonance amplification. ENTRO-DASA provides a principled four-module cybernetic governance pipeline that classifies any cognitive trajectory state as:

| Signal | Deviation Status | Action |
|---|---|---|
| 🟢 **CONSISTENCY LOCK** | `D_j(t) ≤ θ_warn` | Certified attractor basin confinement |
| 🟠 **MONITORING PHASE** | `θ_warn < D_j ≤ θ_crit` | Preventive gravity adjustment |
| 🔴 **CRITICAL DEVIATION** | `D_j(t) > θ_crit` | Immediate trajectory recapture via α-amplification |

---

## 🗂️ Table of Contents

- [Overview](#-overview)
- [Key Features](#-key-features)
- [Project Structure](#-project-structure)
- [Quick Start](#-quick-start)
- [ENTRO-DASA Pipeline](#-entro-dasa-pipeline)
- [Scoring Function](#-scoring-function)
- [Platforms & Mirrors](#-platforms--mirrors)
- [Clone & Download](#-clone--download)
- [Citation](#-citation)
- [License](#-license)
- [Author](#-author)

---

## ✨ Key Features

- **Four-module governance pipeline** — DASA Core Engine, Strategic Analytics Module, Visualization Stack, Digital Archival Infrastructure
- **Adaptive Linguistic Gravity (ALG)** — dynamic restoring force modulated in real time by measured trajectory deviation
- **Multi-trajectory swarm governance** — three parallel cognitive swarms T₁, T₂, T₃ with inter-trajectory synchronization
- **Consistency Lock mechanism** — hard Consistency Basin projection preventing post-lock drift under bounded noise
- **Stochastic Lyapunov stability guarantee** — certified convergence for σ < σ_crit ≈ 0.38
- **Real-time Streamlit + Plotly 3D visualization** — live geodesic trajectory rendering and CCS monitoring
- **JSON/CSV temporal archiving** — SHA-256 append-only tamper-evident operational history
- **Full open-source distribution** — available across 11 platforms

---

## 📁 Project Structure

```
ENTRO-DASA/
│
├── entro_dasa/                         # Core Python package
│   ├── __init__.py                     # Package entry point & public API
│   ├── pipeline.py                     # Main ENTRO-DASA governance pipeline
│   ├── score.py                        # CCS scoring function & decision logic
│   │
│   ├── modules/                        # Governance modules
│   │   ├── __init__.py
│   │   ├── dasa_core.py                # Module 1: DASA Core Engine (DCE)
│   │   ├── analytics.py                # Module 2: Strategic Analytics Module (SAM)
│   │   ├── consistency_lock.py         # Module 3: Consistency Basin enforcement
│   │   └── synchronizer.py             # Module 4: Inter-trajectory synchronization
│   │
│   ├── gravity/                        # Adaptive Linguistic Gravity subsystem
│   │   ├── __init__.py
│   │   ├── algr.py                     # Adaptive Linguistic Gravity Rule kernel
│   │   ├── attractor.py                # Sovereign Attractor (A*) field generator
│   │   └── potential.py                # DASA Cognitive Well V(x) computation
│   │
│   ├── trajectory/                     # Trajectory management
│   │   ├── __init__.py
│   │   ├── swarm.py                    # Multi-trajectory swarm T₁, T₂, T₃ manager
│   │   ├── geodesic.py                 # Geodesic cognitive routing engine
│   │   └── deviation.py                # Deviation metric D_{i,j}(t) computation
│   │
│   ├── stochastic/                     # Stochastic perturbation modeling
│   │   ├── __init__.py
│   │   ├── noise.py                    # Gaussian perturbation operator η ~ N(0, σ²I)
│   │   ├── lyapunov.py                 # Stochastic Lyapunov stability analysis
│   │   └── phase_transition.py         # Phase transition characterization
│   │
│   ├── adaptive/                       # Adaptive feedback regulation
│   │   ├── __init__.py
│   │   ├── memory.py                   # Temporal memory stabilization (M-window)
│   │   └── feedback.py                 # Outer-loop adaptive parameter optimization
│   │
│   └── utils/                          # Shared utilities
│       ├── __init__.py
│       ├── metrics.py                  # CCS, CERI, FDR computation
│       ├── validators.py               # Input validation & type checking
│       └── constants.py                # Canonical parameter registry
│
├── visualization/                      # Real-time visualization subsystem
│   ├── __init__.py
│   ├── app.py                          # Streamlit application entry point
│   ├── dashboard.py                    # Main dashboard layout & controls
│   ├── plot3d.py                       # Plotly 3D trajectory renderer
│   ├── timeseries.py                   # CCS / deviation time-series panels
│   └── components/
│       ├── attractor_sphere.py         # Consistency Basin 3D sphere renderer
│       ├── swarm_cloud.py              # Point cloud trajectory renderer
│       └── status_panel.py             # 🔴🟠🟢 signal status panel
│
├── archival/                           # Digital Archival Framework (DAF)
│   ├── __init__.py
│   ├── writer.py                       # Append-only JSON/CSV record writer
│   ├── checksum.py                     # SHA-256 tamper-evidence layer
│   └── partitioner.py                  # Per-trajectory time-window CSV partitioner
│
├── simulation/                         # Experimental simulation environment
│   ├── __init__.py
│   ├── environment.py                  # Noise regime configuration (low/moderate/high)
│   ├── benchmarks.py                   # Five-configuration comparative stability suite
│   ├── parameters.py                   # Canonical v10.2 parameter registry
│   └── results/                        # Pre-computed simulation outputs
│       ├── stability_comparison.json
│       ├── entropy_suppression.json
│       └── phase_transition_sweep.json
│
├── examples/                           # Usage examples & tutorials
│   ├── quickstart.py                   # Minimal working example
│   ├── basic_governance.ipynb          # Jupyter: single-trajectory governance
│   ├── swarm_demo.ipynb                # Jupyter: multi-trajectory swarm simulation
│   ├── noise_resistance.ipynb          # Jupyter: stochastic Lyapunov analysis
│   ├── streamlit_live.py               # Launch real-time 3D dashboard
│   └── custom_attractor.py             # Custom A* specification example
│
├── tests/                              # Unit and integration tests
│   ├── test_dasa_core.py
│   ├── test_algr.py
│   ├── test_consistency_lock.py
│   ├── test_synchronizer.py
│   ├── test_stochastic.py
│   ├── test_pipeline.py
│   ├── test_scoring.py
│   └── test_archival.py
│
├── docs/                               # Documentation source
│   ├── architecture.md                 # Pipeline & module architecture reference
│   ├── mathematics.md                  # Full mathematical formalism documentation
│   ├── governance.md                   # Governance protocol & threshold calibration
│   ├── visualization.md                # Streamlit + Plotly setup guide
│   └── api_reference.md                # Full Python API reference
│
├── paper/                              # Research paper artifacts
│   ├── ENTRO-DASA_Research_Paper.pdf   # Published paper (PDF)
│   ├── ENTRO-DASA_Research_Paper.docx  # Editable Word version
│   └── figures/                        # Paper figures & diagrams
│       ├── pipeline_diagram.svg
│       ├── phase_transition_plot.svg
│       └── attractor_basin_3d.svg
│
├── .gitlab-ci.yml                      # GitLab CI/CD pipeline
├── .github/                            # GitHub Actions workflows
│   └── workflows/
│       ├── tests.yml
│       └── publish.yml
├── pyproject.toml                      # Build system configuration
├── setup.cfg                           # Package metadata
├── requirements.txt                    # Runtime dependencies
├── requirements-dev.txt                # Development dependencies
├── CHANGELOG.md                        # Version history (v1.0 → v10.2)
├── CONTRIBUTING.md                     # Contribution guidelines
├── CODE_OF_CONDUCT.md
├── AUTHORS.md                          # Author and contributor registry
├── LICENSE                             # MIT License
└── README.md                           # This file
```

---

## 🚀 Quick Start

### Installation

```bash
# Install from PyPI
pip install entro-dasa

# Install from source
git clone https://github.com/gitdeeper12/ENTRO-DASA.git
cd ENTRO-DASA
pip install -e .
```

### Minimal Example

```python
from entro_dasa import DASAGovernor

# Initialize the governor with sovereign attractor at origin
governor = DASAGovernor(attractor=[0.0, 0.0, 0.0])

# X: trajectory state matrix of shape (n_points, 3)
# Run governance pipeline across T_max steps
result = governor.run(X, T_max=500)

print(result.label)           # "CONSISTENCY_LOCK" | "MONITORING" | "CRITICAL"
print(result.ccs_score)       # float in [0, 1] — Convergence Concordance Score
print(result.breakdown)       # {"S": 0.94, "R": 0.92, "I": 0.97, "D": 0.89}
print(result.entropy_ceri)    # Cognitive Entropy Reduction Index
print(result.failure_modes)   # list of detected deviation events (if any)
```

### With Custom Gravity Parameters

```python
from entro_dasa import DASAGovernor

governor = DASAGovernor(
    attractor=[0.0, 0.0, 0.0],
    params={
        "alpha":    1.05,   # amplification exponent (critical deviation)
        "beta":     0.98,   # damping exponent (below threshold)
        "theta":    0.80,   # critical deviation threshold
        "gamma":    0.05,   # computational step rate
        "w0":       1.00,   # baseline gravity coefficient
        "lambda_q": 0.01,   # quartic regularization constant
        "kappa_s":  0.10,   # inter-trajectory synchronization coefficient
        "sigma":    0.15,   # environmental noise level (for simulation)
    }
)
result = governor.run(X, T_max=500, n_swarms=3)
```

### With Learnable Adaptive Layer

```python
from entro_dasa import DASAGovernor
from entro_dasa.adaptive import AdaptiveFeedback

# Load outer-loop adaptive parameter optimizer
adapter = AdaptiveFeedback.from_pretrained("default")
governor = DASAGovernor(attractor=[0.0, 0.0, 0.0], adapter=adapter)

# Adaptive layer recalibrates α, β, θ, κ_s based on runtime performance
result = governor.run(X, T_max=500)
print(result.adapted_params)  # parameter values after adaptive optimization
```

### Launch Real-Time 3D Dashboard

```bash
# Start Streamlit visualization
streamlit run examples/streamlit_live.py

# Dashboard available at: http://localhost:8501
# Live 3D trajectory rendering · CCS time-series · SAM signal status
```

---

## 🧩 ENTRO-DASA Pipeline

```
┌──────────────────────────────────────────────────────────────────┐
│          Cognitive State Input  X ∈ R³  (Trajectories T₁,T₂,T₃) │
└──────────────────────────┬───────────────────────────────────────┘
                           │
         ┌─────────────────┼──────────────────┐
         │                 │                  │
         ▼                 ▼                  ▼
   DASA Core          Stochastic         Geodesic
   Engine (DCE)       Perturbation       Router
   Parallel threads   η ~ N(0, σ²I)      Fisher metric
         │                 │                  │
         └─────────────────┼──────────────────┘
                           │
                           ▼
              Adaptive Linguistic Gravity
              w_{t+1} = w_t · α^[d>θ] · β^[d≤θ]
                           │
                           ▼
              Inter-Trajectory Synchronization
              F_sync = κ_s · (c_j - c_{j'})
                           │
                           ▼
              Strategic Analytics Module (SAM)
              🔴 Critical · 🟠 Monitor · 🟢 Lock
                           │
                           ▼
              Consistency Basin Enforcement
              x(t+1) = Π_{B_C}[ update + η ]
                           │
                           ▼
              Convergence Concordance Score
              CCS = (1/N) Σ exp(-κ · d²_final)
                           │
                  ┌────────┴────────┐
                  ▼                 ▼
          Digital Archive    3D Visualization
          JSON/CSV + SHA-256  Streamlit + Plotly
```

### Module Descriptions

| # | Module | Formula | Description |
|---|--------|---------|-------------|
| 1 | **Trajectory Deviation (d)** | `d_{i,j}(t) = ‖x_{i,j}(t) − A*‖₂` | Instantaneous Euclidean distance from sovereign attractor |
| 2 | **Adaptive Linguistic Gravity (w)** | `w_{t+1} = w_t · α^[d>θ] · β^[d≤θ]` | Dynamic restoring force modulation (α=1.05, β=0.98) |
| 3 | **State Update with Noise** | `x(t+1) = x(t) − γ·w_t·∇V(x) + η` | Gradient-flow guidance + stochastic perturbation |
| 4 | **Convergence Concordance (CCS)** | `CCS = (1/N) Σ exp(−κ·d²_final)` | Certified attractor lock score ∈ [0, 1] |

---

## 📊 Scoring Function

```
CCS_sys = (1/3) · Σ_j CCS_j

Governance certification threshold:  CCS_sys ≥ 0.95

Noise resistance bound (Stochastic Lyapunov):
  √L* ≈ σ / √(2K* − K*²) ≈ 1.90σ   (for K* ≈ 0.15)

DASA Cognitive Well (potential field):
  V(x) = (1/2)·k(t)·‖x − A*‖² + (λ/4)·‖x − A*‖⁴
```

**System performance benchmarks (v10.2, σ = 0.15):**

| Configuration | CCS_sys | FDR | CERI | σ=0.30 CCS |
|---|---|---|---|---|
| ENTRO-DASA (full, v10.2) | **0.97** | **0.03** | **0.94** | **0.89** |
| No Adaptive Gravity (fixed w) | 0.83 | 0.17 | 0.76 | 0.61 |
| No Consistency Lock | 0.91 | 0.09 | 0.87 | 0.74 |
| No Synchronization Force | 0.87 | 0.13 | 0.81 | 0.68 |
| Ungoverned Baseline | 0.29 | 0.63 | 0.12 | 0.14 |

**SAM decision thresholds:**

| Score Range | Classification | Condition |
|---|---|---|
| `CCS_sys ≥ 0.95` | 🟢 CONSISTENCY LOCK | All trajectories within B_C; attractor certified |
| `0.70 ≤ CCS < 0.95` | 🟠 MONITORING PHASE | Partial convergence; gravity adjustment active |
| `CCS < 0.70` | 🔴 CRITICAL DEVIATION | Trajectory recapture required; α-amplification engaged |

---

## 🌐 Platforms & Mirrors

| Platform | URL | Role |
|---|---|---|
| 🐙 **GitHub** (Primary) | [github.com/gitdeeper12/ENTRO-DASA](https://github.com/gitdeeper12/ENTRO-DASA) | Source code, issues, PRs |
| 🦊 **GitLab** (Mirror) | [gitlab.com/gitdeeper12/ENTRO-DASA](https://gitlab.com/gitdeeper12/ENTRO-DASA) | CI/CD mirror |
| 🪣 **Bitbucket** (Mirror) | [bitbucket.org/gitdeeper-12/ENTRO-DASA](https://bitbucket.org/gitdeeper-12/ENTRO-DASA) | Enterprise mirror |
| 🏔️ **Codeberg** (Mirror) | [codeberg.org/gitdeeper12/ENTRO-DASA](https://codeberg.org/gitdeeper12/ENTRO-DASA) | Open-source community |
| 📦 **PyPI** | [pypi.org/project/entro-dasa](https://pypi.org/project/entro-dasa) | Python package distribution |
| 🔬 **Zenodo** | [doi.org/10.5281/zenodo.20353988](https://doi.org/10.5281/zenodo.20353988) | Citable DOI, paper & data |
| 📋 **OSF Project** | [osf.io/xxxxx](https://osf.io/xxxxx) | Research project registry |
| 📝 **OSF Preregistration** | [doi.org/10.17605/OSF.IO/XXXXX](https://doi.org/10.17605/OSF.IO/XXXXX) | Pre-registered study protocol |
| 🌐 **Website** | [entro-dasa.netlify.app](https://entro-dasa.netlify.app) | Live documentation & dashboard |
| 🧑‍🔬 **ORCID** | [orcid.org/0009-0003-8903-0029](https://orcid.org/0009-0003-8903-0029) | Researcher identity |
| 🗄️ **Internet Archive** | [archive.org/details/osf-registrations-xxxxx](https://archive.org/details/osf-registrations-xxxxx) | Permanent archival copy |

### 🌐 Official Website Pages

| Page | URL |
|---|---|
| Homepage | [entro-dasa.netlify.app](https://entro-dasa.netlify.app) |
| Dashboard | [entro-dasa.netlify.app/dashboard](https://entro-dasa.netlify.app/dashboard) |
| Results | [entro-dasa.netlify.app/results](https://entro-dasa.netlify.app/results) |
| Documentation | [entro-dasa.netlify.app/documentation](https://entro-dasa.netlify.app/documentation) |

---

## 🔄 Clone & Download

### Git Clone

```bash
# GitHub (Primary)
git clone https://github.com/gitdeeper12/ENTRO-DASA.git

# GitLab (Mirror)
git clone https://gitlab.com/gitdeeper12/ENTRO-DASA.git

# Bitbucket (Mirror)
git clone https://bitbucket.org/gitdeeper-12/ENTRO-DASA.git

# Codeberg (Mirror)
git clone https://codeberg.org/gitdeeper12/ENTRO-DASA.git
```

### Direct ZIP Download

| Source | Link |
|---|---|
| GitHub | [ENTRO-DASA-main.zip](https://github.com/gitdeeper12/ENTRO-DASA/archive/refs/heads/main.zip) |
| GitLab | [ENTRO-DASA-main.zip](https://gitlab.com/gitdeeper12/ENTRO-DASA/-/archive/main/ENTRO-DASA-main.zip) |
| Bitbucket | [ENTRO-DASA-main.zip](https://bitbucket.org/gitdeeper-12/ENTRO-DASA/get/main.zip) |
| Codeberg | [ENTRO-DASA-main.zip](https://codeberg.org/gitdeeper12/ENTRO-DASA/archive/main.zip) |
| PyPI files | [pypi.org/project/entro-dasa/#files](https://pypi.org/project/entro-dasa/#files) |
| Zenodo record | [doi.org/10.5281/zenodo.20353988](https://doi.org/10.5281/zenodo.20353988) |

---

## 📖 Citation

If ENTRO-DASA contributes to your research, please cite using one of the following formats.

### 📦 PyPI Package

```bibtex
@software{baladi2026entrodasa_pypi,
  author       = {Baladi, Samir},
  title        = {{ENTRO-DASA}: Dynamic Autonomous Sovereignty Algorithm},
  year         = {2026},
  version      = {10.2.0},
  publisher    = {Python Package Index},
  url          = {https://pypi.org/project/entro-dasa},
  note         = {Python package, MIT License, EntropyLab Series E-LAB-12}
}
```

### 🔬 Zenodo Archive (Paper & Data)

```bibtex
@dataset{baladi2026entrodasa_zenodo,
  author       = {Baladi, Samir},
  title        = {{ENTRO-DASA}: Dynamic Autonomous Sovereignty Algorithm —
                  Research Paper and Simulation Data},
  year         = {2026},
  publisher    = {Zenodo},
  version      = {10.2.0},
  doi          = {10.5281/zenodo.20353988},
  url          = {https://doi.org/10.5281/zenodo.20353988},
  series       = {E-LAB-12}
}
```

### 📝 OSF Preregistration

```bibtex
@misc{baladi2026entrodasa_osf,
  author       = {Baladi, Samir},
  title        = {{ENTRO-DASA} Framework: Pre-registered Study Protocol for
                  Cybernetic Governance of Dissipative Cognition Systems},
  year         = {2026},
  publisher    = {Open Science Framework},
  doi          = {10.17605/OSF.IO/XXXXX},
  url          = {https://doi.org/10.17605/OSF.IO/XXXXX},
  note         = {OSF Preregistration}
}
```

### 📄 Research Paper

```bibtex
@article{baladi2026entrodasa,
  author       = {Baladi, Samir},
  title        = {{ENTRO-DASA}: A Cybernetic Framework for Multi-Trajectory
                  Attractor Guidance and Self-Regulating Consistency Locks
                  in Dissipative Cognition Systems},
  year         = {2026},
  month        = {May},
  series       = {E-LAB-12},
  version      = {10.2.0},
  doi          = {10.5281/zenodo.20353988},
  url          = {https://doi.org/10.5281/zenodo.20353988},
  note         = {Ronin Institute / Rite of Renaissance}
}
```

### APA (inline)

> Baladi, S. (2026). *ENTRO-DASA: A Cybernetic Framework for Multi-Trajectory Attractor Guidance and Self-Regulating Consistency Locks in Dissipative Cognition Systems* (Version 10.2.0, Series E-LAB-12). Zenodo. https://doi.org/10.5281/zenodo.20353988

---

## 📜 License

This project is licensed under the **MIT License** — see the [LICENSE](LICENSE) file for details.

```
MIT License

Copyright (c) 2026 Samir Baladi

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction...
```

---

## 👤 Author

**Samir Baladi**
Interdisciplinary AI Researcher — Neural Engineering & Cybernetic Systems
Ronin Institute / Rite of Renaissance · EntropyLab Series

| Contact | Link |
|---|---|
| 📧 Email | [gitdeeper@gmail.com](mailto:gitdeeper@gmail.com) |
| 🧑‍🔬 ORCID | [0009-0003-8903-0029](https://orcid.org/0009-0003-8903-0029) |
| 🐙 GitHub | [github.com/gitdeeper12](https://github.com/gitdeeper12) |
| 🌐 Website | [entro-dasa.netlify.app](https://entro-dasa.netlify.app) |

---

<div align="center">

**Series E-LAB-12 · Project 60 · Version 10.2.0 · May 2026**

[![DOI](https://img.shields.io/badge/DOI-10.5281%2Fzenodo.20353988-blue.svg)](https://doi.org/10.5281/zenodo.20353988)
[![PyPI](https://img.shields.io/pypi/v/entro-dasa?color=0B1F3A)](https://pypi.org/project/entro-dasa)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

*"Computational sovereignty is not assumed — it is enforced."*

</div>
