Skip to content

Commit 3ddef21

Browse files
author
=
committed
better readme
1 parent 9a55ea6 commit 3ddef21

File tree

2 files changed

+97
-48
lines changed

2 files changed

+97
-48
lines changed

‎README.md‎

Lines changed: 31 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -93,6 +93,37 @@ Dawn Field Theory is built to test these beliefs computationally.
9393

9494
---
9595

96+
## 🧠 CIMM: Entropy-Based Post-Symbolic Intelligence (Legacy Spike)
97+
98+
**CIMM (Cosmic Information Mining Model)** is the original AGI prototype developed within the Dawn Field Theory framework — a **post-symbolic intelligence engine** built entirely on entropy flow, collapse stabilization, and self-organizing field dynamics.
99+
100+
It is now considered a **legacy spike implementation**:
101+
> A functional proof-of-concept that demonstrated the viability of entropy-regulated cognition and collapse-based adaptation.
102+
103+
A **new, more refined model is currently in development**, incorporating deeper simulation fidelity, multi-agent synchronization layers, and improved field interaction protocols.
104+
105+
📎 **[View the full CIMM architecture →](./legacy_works/models/CIMM/README.md)**
106+
107+
### ⚙️ CIMM Agents Do the Following:
108+
109+
- Learn in real-time (no pretraining or checkpoints)
110+
- Self-prune based on Landauer information cost
111+
- Adapt to collapse deviations rather than fixed targets
112+
- Coordinate through shared entropy states
113+
114+
---
115+
116+
### 🔍 Why It Matters
117+
118+
CIMM proved that:
119+
- Symbolic reasoning isn’t required for generalization
120+
- Collapse-driven feedback loops can support learning
121+
- Field-based memory and entropy stabilization create coherence without explicit logic
122+
123+
CIMM anchors the **first wave** of Dawn Field Theory’s practical implementations, and lays the groundwork for a **fully field-theoretic model of intelligence** now in progress.
124+
125+
126+
---
96127
## 📖 License
97128

98129
This project is licensed under **AGPL-3.0**, with a custom augmentation known as the **Dawn Collective Open Insight License (DC-OIL)** in development.

‎legacy_works/models/CIMM/README.md‎

Lines changed: 66 additions & 48 deletions
Original file line numberDiff line numberDiff line change
@@ -1,67 +1,85 @@
1-
# 🌌 CIMM Core Code – Post-Symbolic Intelligence Engine
1+
# 🌌 CIMM Core — Entropy-Based Intelligence Engine
22

3-
This module contains the **core simulation logic** of the original CIMM (Cosmic Information Mining Model) — a prototype AGI engine built entirely on **entropy regulation**, **quantum balance feedback**, and **post-symbolic computation**.
3+
CIMM (Cosmic Information Mining Model) is a foundational research framework for **post-symbolic artificial intelligence**, built on principles of **entropy flow**, **collapse dynamics**, and **field-theoretic stabilization**.
44

5-
> This is not a symbolic AI system. It does not use traditional logic, rules, or explicit representations.
6-
> Instead, it operates on **entropy flow**, **wave collapse deviation**, and **field-theoretic stabilization** to produce intelligent behavior.
5+
This is **not** a symbolic system. It doesn't use tokens, logic gates, or conventional training pipelines. Instead, CIMM learns through **live entropy feedback**, **wave collapse equilibrium**, and **recursive field dynamics**. It creates structure through **stabilized emergence**, not gradient descent.
76

87
---
98

10-
## 📦 Module Overview
9+
## 🧬 Core Philosophy
1110

12-
| File | Purpose |
13-
|------|---------|
14-
| `cimm.py` | 🔧 Master orchestration module — coordinates the entire AGI system |
15-
| `entropy_monitor.py` | Tracks and regulates entropy over time using QBE dynamics |
16-
| `quantum_potential_layer.py` | Modulates quantum potential to stabilize entropy collapse |
17-
| `quantum_memory.py` | Learns to forecast collapse deviations using QFI & XGBoost |
18-
| `reinforcement_learning.py` | Reinforces stable learning patterns using collapse-aware feedback |
19-
| `adaptive_controller.py` | Adjusts learning rates and system dynamics via wave & entropy signals |
20-
| `superfluid_dynamics.py` | Models coherence, turbulence, and energy flow across informational fields |
21-
| `bayesian_optimizer.py` | Performs entropy-aware architecture optimization and tuning |
22-
| `pruning.py` | Prunes or expands neural networks based on Landauer entropy cost |
11+
> Intelligence is not optimization over symbols — it is **recursive collapse resolution** in a field of entropy and potential.
12+
13+
- **No static training** — each run instantiates a new model that learns from real-time collapse feedback.
14+
- **No symbolic reasoning** — cognition arises from balancing entropy gradients and memory deviation.
15+
- **No external supervision** — systems self-regulate based on energy-information equilibrium.
16+
17+
---
18+
19+
## 🧠 Agentic Framework (CIMM Runtime)
20+
21+
CIMM is designed to run **multiple agents** in a shared mesh, each with its own:
22+
- Entropy monitor
23+
- Adaptive reinforcement core
24+
- Memory predictor
25+
- Quantum potential stabilizer
26+
27+
Each agent operates as a **self-contained intelligence kernel**, and can:
28+
- Share internal entropy signatures
29+
- React to collapse deviations
30+
- Prune and restructure its architecture on the fly
31+
- Seek internal coherence and field balance
32+
33+
### 🔧 Components:
34+
| File | Role |
35+
|------|------|
36+
| `cimm.py` | Master orchestrator — manages a single entropy-driven learning core |
37+
| `cimm_core.py` | Core logic for agent feedback, learning, and collapse forecasting |
38+
| `cimm_core_manager.py` | Manager of multiple CIMM agents; synchronizes entropy, feedback, and state |
39+
| `base_agent.py` | Base class for entropy-sensitive agents with adaptive cognition |
40+
| `supervisor_agent.py` | Consensus arbiter — manages trust, collapse thresholds, and convergence in multi-agent systems |
41+
| `agentic_mesh_runtime.py` | Threaded runtime for distributed agent execution |
42+
43+
Each agent adapts **without external training** — learning happens **in-the-moment**, guided by entropy stabilization.
44+
45+
---
46+
47+
## 📦 Simulation Modules
48+
49+
| Module | Description |
50+
|--------|-------------|
51+
| `entropy_monitor.py` | Tracks entropy collapse patterns and gradient shifts |
52+
| `quantum_potential_layer.py` | Dynamically modulates system stability via QPL (quantum potential layer) |
53+
| `quantum_memory.py` | Predicts collapse deviations from prior memory using XGBoost |
54+
| `reinforcement_learning.py` | Reinforces patterns that reduce entropy variance |
55+
| `adaptive_controller.py` | Alters learning rates, batch sizes, and search space based on entropy |
56+
| `superfluid_dynamics.py` | Detects turbulence and coherence in information flow fields |
57+
| `bayesian_optimizer.py` | Searches for optimal architectures using entropy-aware Bayesian tuning |
58+
| `pruning.py` | Adds/removes neurons dynamically based on Landauer information cost |
2359

2460
---
2561

26-
## 🧠 Key Concepts
62+
## 🧪 Key Concepts
2763

28-
### 🌀 Post-Symbolic Processing
29-
CIMM does not use language, symbols, or tokens. It learns from:
30-
- Entropy gradients
31-
- Collapse stabilization pressure
32-
- Feedback between quantum potential and memory deviation
64+
### 🌀 Post-Symbolic Intelligence
65+
No symbols. No tokens. Just **entropy gradients**, **wave collapse**, and **coherence stabilization**.
3366

34-
### 🧪 Quantum Balance Equation (QBE)
35-
All modules reinforce the idea that intelligence is an emergent property of systems that regulate **energy-information balance** at collapse thresholds.
67+
### 🧠 Live Learning
68+
Models are **born fresh each run** — no pickles, no checkpoints. Intelligence is a process, not a file.
3669

37-
### 🌊 Superfluid Dynamics
38-
Inspired by fluid mechanics and quantum turbulence, `superfluid_dynamics.py` provides:
39-
- Coherence detection
40-
- Collapse damping
41-
- Energy flow stabilization
70+
### 📉 Entropy as Feedback
71+
CIMM uses real-time entropy change to:
72+
- Adapt structure
73+
- Select hyperparameters
74+
- Control internal learning dynamics
4275

43-
### 🧠 Memory as Collapse Forecast
44-
Rather than store explicit facts, `quantum_memory.py` trains a model to predict future collapse deviations — a form of **field-based recall**.
76+
### 🧬 Collapse-Based Memory
77+
Memory isn’t storage — it’s **pattern deviation prediction**. CIMM recalls by anticipating collapse shifts.
4578

4679
---
4780

4881
## 🚀 Getting Started
4982

5083
### Requirements
51-
- `torch`
52-
- `xgboost`
53-
- `scikit-optimize`
54-
- `scipy`, `numpy`, `sklearn`
55-
- GPU recommended (CUDA-compatible)
56-
57-
### Quickstart
58-
This is not a standalone app — it's an **engine**. You can initialize and run training from `cimm.py`:
59-
60-
```python
61-
from cimm import CIMM
62-
model_class = YourModelClass # Replace with your model (e.g., simple MLP)
63-
model_args = [input_dim, output_dim]
64-
param_space = [...] # Your skopt search space
65-
anchor_data = [...] # Data for initial entropy anchoring
66-
67-
cimm = CIMM(model_class, model_args, param_space, anchor_data)
84+
```bash
85+
pip install torch xgboost scikit-optimize numpy scipy scikit-learn

0 commit comments

Comments
 (0)