ruvector/crates/ruvector-exotic-wasm

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