Skip to content

Latest commit

 

History

History
447 lines (330 loc) · 13.7 KB

README.md

File metadata and controls

447 lines (330 loc) · 13.7 KB

ruvector-exotic-wasm

Exotic AI mechanisms for emergent behavior in distributed systems. This WASM module provides novel coordination primitives inspired by decentralized governance, developmental biology, and quantum physics.

Installation

npm install ruvector-exotic-wasm

Quick Start

import init, {
  WasmNAO,
  WasmMorphogeneticNetwork,
  WasmTimeCrystal,
  ExoticEcosystem,
  version,
  available_mechanisms
} from 'ruvector-exotic-wasm';

// Initialize the WASM module
await init();

console.log('Version:', version());
console.log('Available mechanisms:', available_mechanisms());

API Reference

Neural Autonomous Organization (NAO)

Decentralized governance for AI agent collectives using stake-weighted quadratic voting and oscillatory synchronization for coherence.

Constructor

new WasmNAO(quorum_threshold: number): WasmNAO

Creates a new NAO with the specified quorum threshold (0.0 - 1.0).

Methods

Method Signature Description
addMember (agent_id: string, stake: number): void Add a member agent with initial stake
removeMember (agent_id: string): void Remove a member agent
memberCount (): number Get the number of members
propose (action: string): string Create a proposal, returns proposal ID
vote (proposal_id: string, agent_id: string, weight: number): boolean Vote on a proposal (-1.0 to 1.0)
execute (proposal_id: string): boolean Execute a proposal if consensus reached
tick (dt: number): void Advance simulation by one time step
synchronization (): number Get current sync level (0-1)
agentCoherence (agent_a: string, agent_b: string): number Get coherence between two agents
activeProposalCount (): number Get number of active proposals
totalVotingPower (): number Get total voting power in the org
currentTick (): number Get current simulation tick
toJson (): any Export all data as JSON
free (): void Free memory (or use Symbol.dispose)

Example

import init, { WasmNAO } from 'ruvector-exotic-wasm';

await init();

// Create NAO with 70% quorum requirement
const nao = new WasmNAO(0.7);

// Add agents with stake (voting power = sqrt(stake))
nao.addMember("agent_alpha", 100);  // 10 voting power
nao.addMember("agent_beta", 50);    // ~7.07 voting power
nao.addMember("agent_gamma", 25);   // 5 voting power

// Create a proposal
const proposalId = nao.propose("Upgrade to quantum backend");

// Agents vote (-1.0 = strongly against, 1.0 = strongly for)
nao.vote(proposalId, "agent_alpha", 0.9);
nao.vote(proposalId, "agent_beta", 0.6);
nao.vote(proposalId, "agent_gamma", 0.8);

// Run oscillatory synchronization
for (let i = 0; i < 100; i++) {
  nao.tick(0.001);
}

console.log("Synchronization level:", nao.synchronization());
console.log("Agent coherence:", nao.agentCoherence("agent_alpha", "agent_beta"));

// Execute if consensus reached
if (nao.execute(proposalId)) {
  console.log("Proposal executed!");
}

// Clean up
nao.free();

Morphogenetic Network

Biologically-inspired network growth with cellular differentiation through morphogen gradients, emergent network topology, and synaptic pruning.

Constructor

new WasmMorphogeneticNetwork(width: number, height: number): WasmMorphogeneticNetwork

Creates a new morphogenetic network with the specified grid dimensions.

Methods

Method Signature Description
seedStem (x: number, y: number): number Seed a stem cell, returns cell ID
seedSignaling (x: number, y: number): number Seed a signaling cell, returns cell ID
addGrowthSource (x: number, y: number, name: string, concentration: number): void Add a growth factor source
grow (dt: number): void Grow the network for one time step
differentiate (): void Differentiate stem cells based on signals
prune (threshold: number): void Remove weak connections and dead cells
cellCount (): number Get total cell count
stemCount (): number Get stem cell count
computeCount (): number Get compute cell count
signalingCount (): number Get signaling cell count
currentTick (): number Get current simulation tick
statsJson (): any Get network statistics as JSON
cellsJson (): any Get all cells as JSON
free (): void Free memory (or use Symbol.dispose)

Cell Types

  • Stem: Undifferentiated cells that can become any type
  • Signaling: Produce growth factors (morphogens)
  • Receptor: Respond to signals from signaling cells
  • Structural: Form the network backbone
  • Compute: Perform local computation with internal state

Example

import init, { WasmMorphogeneticNetwork } from 'ruvector-exotic-wasm';

await init();

// Create a 100x100 grid
const network = new WasmMorphogeneticNetwork(100, 100);

// Seed signaling cells (morphogen sources)
network.seedSignaling(50, 50);
network.seedSignaling(25, 75);
network.seedSignaling(75, 25);

// Seed stem cells that will differentiate
for (let i = 0; i < 20; i++) {
  const x = Math.floor(Math.random() * 100);
  const y = Math.floor(Math.random() * 100);
  network.seedStem(x, y);
}

// Add growth factor sources
network.addGrowthSource(50, 50, "compute", 1.0);

// Run growth simulation
for (let step = 0; step < 500; step++) {
  network.grow(0.1);

  // Differentiate every 10 steps
  if (step % 10 === 0) {
    network.differentiate();
  }

  // Prune every 100 steps
  if (step % 100 === 0) {
    network.prune(0.1);
  }
}

// Get statistics
const stats = network.statsJson();
console.log("Total cells:", stats.total_cells);
console.log("Connections:", stats.total_connections);
console.log("Average fitness:", stats.average_fitness);
console.log("Cell types:", stats.type_counts);

// Get all cell data
const cells = network.cellsJson();
console.log("First cell:", cells[0]);

network.free();

Time Crystal Coordinator

Robust distributed coordination using discrete time crystal dynamics with period-doubled oscillations (Floquet engineering) for noise-resilient phase-locked agent synchronization.

Constructor

new WasmTimeCrystal(n: number, period_ms: number): WasmTimeCrystal

Creates a new time crystal with n oscillators and the specified period in milliseconds.

Static Methods

Method Signature Description
synchronized (n: number, period_ms: number): WasmTimeCrystal Create a pre-synchronized crystal

Instance Methods

Method Signature Description
crystallize (): void Establish stable periodic order
tick (): Uint8Array Advance one step, returns coordination pattern
orderParameter (): number Get synchronization level (0-1)
oscillatorCount (): number Get number of oscillators
isCrystallized (): boolean Check if crystal is in ordered phase
currentStep (): number Get current time step
periodMs (): number Get period in milliseconds
robustness (): number Get robustness measure
collectiveSpin (): number Get collective spin (-1 to 1)
patternType (): string Get current pattern type
perturb (strength: number): void Apply external perturbation
setCoupling (coupling: number): void Set oscillator coupling strength
setDriving (strength: number): void Set Floquet driving strength
setDisorder (disorder: number): void Set noise/disorder level
phasesJson (): any Get all phases as JSON array
signalsJson (): any Get all signals as JSON array
free (): void Free memory (or use Symbol.dispose)

Coordination Patterns

  • Coherent: All oscillators in phase (full coherence)
  • PeriodDoubled: Time crystal signature (period-doubled oscillation)
  • AntiPhase: Two-group anti-phase clustering
  • Quasiperiodic: Complex multi-frequency pattern
  • Disordered: No stable pattern (thermal/noisy state)

Example

import init, { WasmTimeCrystal } from 'ruvector-exotic-wasm';

await init();

// Create a 16-oscillator time crystal with 100ms period
const crystal = new WasmTimeCrystal(16, 100);

// Crystallize to establish periodic order
crystal.crystallize();
console.log("Crystallized:", crystal.isCrystallized());

// Configure crystal parameters
crystal.setCoupling(3.0);
crystal.setDriving(Math.PI);  // Pi pulse
crystal.setDisorder(0.05);     // Low noise

// Run coordination loop
for (let i = 0; i < 200; i++) {
  // Get coordination pattern (bit pattern)
  const pattern = crystal.tick();

  // Use pattern for agent coordination
  // Each bit indicates whether oscillator i is in "up" state
  const activeAgents = [];
  for (let j = 0; j < crystal.oscillatorCount(); j++) {
    const byteIdx = Math.floor(j / 8);
    const bitIdx = j % 8;
    if (pattern[byteIdx] & (1 << bitIdx)) {
      activeAgents.push(j);
    }
  }

  if (i % 50 === 0) {
    console.log(`Step ${i}:`, {
      order: crystal.orderParameter().toFixed(3),
      pattern: crystal.patternType(),
      activeAgents: activeAgents.length,
      spin: crystal.collectiveSpin().toFixed(3)
    });
  }
}

// Test perturbation resilience
console.log("Before perturbation:", crystal.orderParameter());
crystal.perturb(0.3);
console.log("After perturbation:", crystal.orderParameter());

// Recovery
for (let i = 0; i < 100; i++) {
  crystal.tick();
}
console.log("After recovery:", crystal.orderParameter());

crystal.free();

Exotic Ecosystem

Unified demonstration combining all three mechanisms (NAO, Morphogenetic Network, Time Crystal) working together.

Constructor

new ExoticEcosystem(agents: number, grid_size: number, oscillators: number): ExoticEcosystem

Creates an ecosystem with the specified number of agents, grid size, and oscillators.

Methods

Method Signature Description
step (): void Advance all systems by one step
crystallize (): void Crystallize the time crystal
synchronization (): number Get time crystal sync level
cellCount (): number Get morphogenetic network cell count
memberCount (): number Get NAO member count
currentStep (): number Get current simulation step
propose (action: string): string Create NAO proposal
vote (proposal_id: string, agent_id: string, weight: number): boolean Vote on proposal
execute (proposal_id: string): boolean Execute proposal
summaryJson (): any Get comprehensive ecosystem summary
free (): void Free memory

Example

import init, { ExoticEcosystem } from 'ruvector-exotic-wasm';

await init();

// Create ecosystem: 5 agents, 50x50 grid, 8 oscillators
const ecosystem = new ExoticEcosystem(5, 50, 8);

// Crystallize for stable coordination
ecosystem.crystallize();

// Create and vote on proposals
const propId = ecosystem.propose("Initialize swarm protocol");
ecosystem.vote(propId, "agent_0", 1.0);
ecosystem.vote(propId, "agent_1", 0.8);
ecosystem.vote(propId, "agent_2", 0.9);

// Run integrated simulation
for (let i = 0; i < 200; i++) {
  ecosystem.step();

  if (i % 50 === 0) {
    const summary = ecosystem.summaryJson();
    console.log(`Step ${i}:`, {
      sync: summary.crystal.order.toFixed(3),
      cells: summary.network.cells,
      members: summary.nao.members,
      crystallized: summary.crystal.crystallized
    });
  }
}

// Execute proposal after sufficient synchronization
if (ecosystem.execute(propId)) {
  console.log("Proposal executed with ecosystem consensus!");
}

ecosystem.free();

Utility Functions

import init, { version, available_mechanisms } from 'ruvector-exotic-wasm';

await init();

// Get module version
console.log(version());  // "0.1.29"

// Get list of available mechanisms
console.log(available_mechanisms());
// ["NeuralAutonomousOrg", "MorphogeneticNetwork", "TimeCrystal"]

Physics Background

Time Crystals

This implementation is inspired by discrete time crystals (DTCs) demonstrated in:

  • Trapped ion experiments (Monroe group, University of Maryland)
  • NV center diamond systems (Lukin group, Harvard)
  • Superconducting qubits (Google Quantum AI)

Key insight: Period-doubling (or n-tupling) provides robust coordination signals resilient to perturbations.

Morphogenesis

Concepts from developmental biology:

  • Morphogens: Diffusible signaling molecules creating concentration gradients
  • Positional information: Cells read local concentrations to determine fate
  • Growth factors: Control cell division and network expansion
  • Apoptosis: Programmed removal of non-functional components

Oscillatory Synchronization

Based on Kuramoto model dynamics for neural synchronization:

  • Agents modeled as coupled oscillators
  • Synchronization emerges from local interactions
  • Order parameter measures collective coherence

Use Cases

  1. Decentralized AI Governance: Use NAO for stake-weighted collective decision-making in multi-agent systems.

  2. Adaptive Network Topology: Use Morphogenetic Networks for self-organizing distributed system architecture.

  3. Robust Coordination: Use Time Crystals for noise-resilient scheduling and synchronization in distributed systems.

  4. Emergent Behavior: Combine all mechanisms for complex adaptive systems with governance, growth, and coordination.

Build from Source

cd crates/ruvector-exotic-wasm
wasm-pack build --target web --release --out-dir pkg

License

MIT