346 lines
9.8 KiB
Rust
346 lines
9.8 KiB
Rust
//! # RuVector Exotic WASM
|
|
//!
|
|
//! Exotic AI mechanisms for emergent behavior in distributed systems.
|
|
//! This crate provides novel coordination primitives inspired by:
|
|
//!
|
|
//! - **Decentralized governance** (Neural Autonomous Organizations)
|
|
//! - **Developmental biology** (Morphogenetic Networks)
|
|
//! - **Quantum physics** (Time Crystals)
|
|
//!
|
|
//! ## Features
|
|
//!
|
|
//! ### Neural Autonomous Organization (NAO)
|
|
//!
|
|
//! Decentralized governance for AI agent collectives using:
|
|
//! - Stake-weighted quadratic voting
|
|
//! - Oscillatory synchronization for coherence
|
|
//! - Quorum-based consensus
|
|
//!
|
|
//! ```rust
|
|
//! use ruvector_exotic_wasm::nao::NeuralAutonomousOrg;
|
|
//!
|
|
//! let mut nao = NeuralAutonomousOrg::new(0.7); // 70% quorum
|
|
//! nao.add_member("agent_1", 100);
|
|
//! nao.add_member("agent_2", 50);
|
|
//!
|
|
//! let prop_id = nao.propose("Upgrade memory backend");
|
|
//! nao.vote(&prop_id, "agent_1", 0.9);
|
|
//! nao.vote(&prop_id, "agent_2", 0.6);
|
|
//!
|
|
//! if nao.execute(&prop_id) {
|
|
//! println!("Proposal executed!");
|
|
//! }
|
|
//! ```
|
|
//!
|
|
//! ### Morphogenetic Network
|
|
//!
|
|
//! Biologically-inspired network growth with:
|
|
//! - Cellular differentiation through morphogen gradients
|
|
//! - Emergent network topology
|
|
//! - Synaptic pruning for optimization
|
|
//!
|
|
//! ```rust
|
|
//! use ruvector_exotic_wasm::morphogenetic::MorphogeneticNetwork;
|
|
//!
|
|
//! let mut net = MorphogeneticNetwork::new(100, 100);
|
|
//! net.seed_cell(50, 50, ruvector_exotic_wasm::morphogenetic::CellType::Signaling);
|
|
//!
|
|
//! for _ in 0..1000 {
|
|
//! net.grow(0.1);
|
|
//! net.differentiate();
|
|
//! }
|
|
//! net.prune(0.1);
|
|
//! ```
|
|
//!
|
|
//! ### Time Crystal Coordinator
|
|
//!
|
|
//! Robust distributed coordination using discrete time crystal dynamics:
|
|
//! - Period-doubled oscillations for stable coordination
|
|
//! - Floquet engineering for noise resilience
|
|
//! - Phase-locked agent synchronization
|
|
//!
|
|
//! ```rust
|
|
//! use ruvector_exotic_wasm::time_crystal::TimeCrystal;
|
|
//!
|
|
//! let mut crystal = TimeCrystal::new(10, 100); // 10 oscillators, 100ms period
|
|
//! crystal.crystallize();
|
|
//!
|
|
//! for _ in 0..200 {
|
|
//! let pattern = crystal.tick();
|
|
//! // Use pattern for coordination
|
|
//! }
|
|
//! ```
|
|
//!
|
|
//! ## WASM Support
|
|
//!
|
|
//! All structures have WASM bindings via `wasm-bindgen`:
|
|
//!
|
|
//! ```javascript
|
|
//! import { WasmNAO, WasmMorphogeneticNetwork, WasmTimeCrystal } from 'ruvector-exotic-wasm';
|
|
//!
|
|
//! // Neural Autonomous Org
|
|
//! const nao = new WasmNAO(0.7);
|
|
//! nao.addMember("agent_1", 100);
|
|
//! const propId = nao.propose("Action");
|
|
//! nao.vote(propId, "agent_1", 0.9);
|
|
//!
|
|
//! // Morphogenetic Network
|
|
//! const net = new WasmMorphogeneticNetwork(100, 100);
|
|
//! net.seedSignaling(50, 50);
|
|
//! net.grow(0.1);
|
|
//!
|
|
//! // Time Crystal
|
|
//! const crystal = new WasmTimeCrystal(10, 100);
|
|
//! crystal.crystallize();
|
|
//! const pattern = crystal.tick();
|
|
//! ```
|
|
|
|
use wasm_bindgen::prelude::*;
|
|
|
|
pub mod morphogenetic;
|
|
pub mod nao;
|
|
pub mod time_crystal;
|
|
|
|
// Re-export main types
|
|
pub use morphogenetic::{Cell, CellType, GrowthFactor, MorphogeneticNetwork, NetworkStats};
|
|
pub use nao::{NeuralAutonomousOrg, OscillatorySynchronizer, Proposal, ProposalStatus};
|
|
pub use time_crystal::{CoordinationPattern, Oscillator, TimeCrystal};
|
|
|
|
// Re-export WASM types
|
|
pub use morphogenetic::WasmMorphogeneticNetwork;
|
|
pub use nao::WasmNAO;
|
|
pub use time_crystal::WasmTimeCrystal;
|
|
|
|
/// Initialize the WASM module with panic hook
|
|
#[wasm_bindgen(start)]
|
|
pub fn init() {
|
|
#[cfg(feature = "console_error_panic_hook")]
|
|
console_error_panic_hook::set_once();
|
|
}
|
|
|
|
/// Get the version of the ruvector-exotic-wasm crate
|
|
#[wasm_bindgen]
|
|
pub fn version() -> String {
|
|
env!("CARGO_PKG_VERSION").to_string()
|
|
}
|
|
|
|
/// Get information about available exotic mechanisms
|
|
#[wasm_bindgen]
|
|
pub fn available_mechanisms() -> JsValue {
|
|
let mechanisms = vec!["NeuralAutonomousOrg", "MorphogeneticNetwork", "TimeCrystal"];
|
|
serde_wasm_bindgen::to_value(&mechanisms).unwrap()
|
|
}
|
|
|
|
/// Create a demonstration of all three exotic mechanisms working together
|
|
#[wasm_bindgen]
|
|
pub struct ExoticEcosystem {
|
|
nao: nao::NeuralAutonomousOrg,
|
|
network: morphogenetic::MorphogeneticNetwork,
|
|
crystal: time_crystal::TimeCrystal,
|
|
step: u64,
|
|
}
|
|
|
|
#[wasm_bindgen]
|
|
impl ExoticEcosystem {
|
|
/// Create a new exotic ecosystem with interconnected mechanisms
|
|
#[wasm_bindgen(constructor)]
|
|
pub fn new(agents: usize, grid_size: i32, oscillators: usize) -> Self {
|
|
let mut nao = nao::NeuralAutonomousOrg::new(0.5);
|
|
let mut network = morphogenetic::MorphogeneticNetwork::new(grid_size, grid_size);
|
|
let crystal = time_crystal::TimeCrystal::new(oscillators, 100);
|
|
|
|
// Initialize agents in NAO
|
|
for i in 0..agents {
|
|
nao.add_member(&format!("agent_{}", i), 100);
|
|
}
|
|
|
|
// Seed some cells in the network
|
|
for i in 0..agents {
|
|
let x = (i as i32 * 10) % grid_size;
|
|
let y = (i as i32 * 7) % grid_size;
|
|
network.seed_cell(x, y, morphogenetic::CellType::Stem);
|
|
}
|
|
|
|
Self {
|
|
nao,
|
|
network,
|
|
crystal,
|
|
step: 0,
|
|
}
|
|
}
|
|
|
|
/// Advance all systems by one step
|
|
pub fn step(&mut self) {
|
|
self.step += 1;
|
|
|
|
// Use crystal coordination pattern to influence other systems
|
|
let pattern = self.crystal.tick();
|
|
|
|
// Use pattern to determine which agents should be active
|
|
let _active_count = pattern
|
|
.iter()
|
|
.map(|b| b.count_ones() as usize)
|
|
.sum::<usize>();
|
|
|
|
// NAO tick with synchronized dynamics
|
|
self.nao.tick(0.001);
|
|
|
|
// Network growth influenced by crystal synchronization
|
|
let sync_level = self.crystal.order_parameter();
|
|
self.network.grow(0.1 * sync_level);
|
|
|
|
// Differentiate periodically
|
|
if self.step % 10 == 0 {
|
|
self.network.differentiate();
|
|
}
|
|
|
|
// Prune occasionally
|
|
if self.step % 100 == 0 {
|
|
self.network.prune(0.05);
|
|
}
|
|
}
|
|
|
|
/// Get current synchronization level (from time crystal)
|
|
pub fn synchronization(&self) -> f32 {
|
|
self.crystal.order_parameter()
|
|
}
|
|
|
|
/// Get current cell count (from morphogenetic network)
|
|
#[wasm_bindgen(js_name = cellCount)]
|
|
pub fn cell_count(&self) -> usize {
|
|
self.network.cell_count()
|
|
}
|
|
|
|
/// Get current member count (from NAO)
|
|
#[wasm_bindgen(js_name = memberCount)]
|
|
pub fn member_count(&self) -> usize {
|
|
self.nao.member_count()
|
|
}
|
|
|
|
/// Get current step
|
|
#[wasm_bindgen(js_name = currentStep)]
|
|
pub fn current_step(&self) -> u32 {
|
|
self.step as u32
|
|
}
|
|
|
|
/// Crystallize the time crystal
|
|
pub fn crystallize(&mut self) {
|
|
self.crystal.crystallize();
|
|
}
|
|
|
|
/// Propose an action in the NAO
|
|
pub fn propose(&mut self, action: &str) -> String {
|
|
self.nao.propose(action)
|
|
}
|
|
|
|
/// Vote on a proposal
|
|
pub fn vote(&mut self, proposal_id: &str, agent_id: &str, weight: f32) -> bool {
|
|
self.nao.vote(proposal_id, agent_id, weight)
|
|
}
|
|
|
|
/// Execute a proposal
|
|
pub fn execute(&mut self, proposal_id: &str) -> bool {
|
|
self.nao.execute(proposal_id)
|
|
}
|
|
|
|
/// Get ecosystem summary as JSON
|
|
#[wasm_bindgen(js_name = summaryJson)]
|
|
pub fn summary_json(&self) -> Result<JsValue, JsValue> {
|
|
let summary = serde_json::json!({
|
|
"step": self.step,
|
|
"nao": {
|
|
"members": self.nao.member_count(),
|
|
"active_proposals": self.nao.active_proposals().len(),
|
|
"synchronization": self.nao.synchronization(),
|
|
},
|
|
"network": {
|
|
"cells": self.network.cell_count(),
|
|
"stats": self.network.stats(),
|
|
},
|
|
"crystal": {
|
|
"oscillators": self.crystal.oscillator_count(),
|
|
"order": self.crystal.order_parameter(),
|
|
"crystallized": self.crystal.is_crystallized(),
|
|
"pattern": format!("{:?}", self.crystal.detect_pattern()),
|
|
}
|
|
});
|
|
|
|
serde_wasm_bindgen::to_value(&summary).map_err(|e| JsValue::from_str(&e.to_string()))
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn test_version() {
|
|
let v = version();
|
|
assert!(!v.is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn test_exotic_ecosystem() {
|
|
let mut eco = ExoticEcosystem::new(5, 50, 8);
|
|
|
|
assert_eq!(eco.member_count(), 5);
|
|
assert!(eco.cell_count() > 0);
|
|
|
|
// Run simulation
|
|
for _ in 0..100 {
|
|
eco.step();
|
|
}
|
|
|
|
assert_eq!(eco.current_step(), 100);
|
|
}
|
|
|
|
#[test]
|
|
fn test_ecosystem_with_crystallization() {
|
|
let mut eco = ExoticEcosystem::new(3, 30, 6);
|
|
|
|
eco.crystallize();
|
|
|
|
// Run with crystallized coordination
|
|
for _ in 0..50 {
|
|
eco.step();
|
|
}
|
|
|
|
// Should have increased synchronization
|
|
assert!(eco.synchronization() > 0.0);
|
|
}
|
|
|
|
#[test]
|
|
fn test_ecosystem_proposal_workflow() {
|
|
let mut eco = ExoticEcosystem::new(3, 30, 6);
|
|
|
|
let prop_id = eco.propose("Test action");
|
|
assert!(eco.vote(&prop_id, "agent_0", 1.0));
|
|
assert!(eco.vote(&prop_id, "agent_1", 0.8));
|
|
|
|
// May or may not execute depending on quorum
|
|
let _result = eco.execute(&prop_id);
|
|
}
|
|
|
|
#[test]
|
|
fn test_all_modules_integrate() {
|
|
// Test that all modules can work together
|
|
let mut nao = NeuralAutonomousOrg::new(0.5);
|
|
let mut network = MorphogeneticNetwork::new(50, 50);
|
|
let mut crystal = TimeCrystal::new(8, 100);
|
|
|
|
nao.add_member("a", 100);
|
|
network.seed_cell(25, 25, CellType::Stem);
|
|
crystal.crystallize();
|
|
|
|
// Run all systems
|
|
for _ in 0..50 {
|
|
nao.tick(0.001);
|
|
network.grow(0.1);
|
|
crystal.tick();
|
|
}
|
|
|
|
assert!(nao.synchronization() > 0.0 || nao.synchronization() == 0.0); // Valid range
|
|
assert!(crystal.order_parameter() >= 0.0);
|
|
}
|
|
}
|