---

📌 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
• Key Features
• Project Structure
• Quick Start
• ENTRO-DASA Pipeline
• Scoring Function
• Platforms & Mirrors
• Clone & Download
• Citation
• License
• 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

# 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

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

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

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

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

🌐 Official Website Pages

Page	URL
Homepage	entro-dasa.netlify.app
Dashboard	entro-dasa.netlify.app/dashboard
Results	entro-dasa.netlify.app/results
Documentation	entro-dasa.netlify.app/documentation

---

🔄 Clone & Download

Git Clone

# 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
GitLab	ENTRO-DASA-main.zip
Bitbucket	ENTRO-DASA-main.zip
Codeberg	ENTRO-DASA-main.zip
PyPI files	pypi.org/project/entro-dasa/#files
Zenodo record	doi.org/10.5281/zenodo.20353988

---

📖 Citation

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

📦 PyPI Package

@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)

@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

@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

@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 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
🧑‍🔬 ORCID	0009-0003-8903-0029
🐙 GitHub	github.com/gitdeeper12
🌐 Website	entro-dasa.netlify.app

---