@aleph-ai/tinyaleph 1.0.0

package/physics/lyapunov.js

@@ -0,0 +1,80 @@
+/**
+ * Lyapunov exponent estimation from phase histories
+ */
+
+function estimateLyapunov(oscillators, windowSize = 20) {
+  if (oscillators[0].phaseHistory.length < windowSize) return 0;
+  
+  let sumLog = 0, count = 0;
+  for (let i = 0; i < oscillators.length - 1; i++) {
+    const h1 = oscillators[i].phaseHistory;
+    const h2 = oscillators[i + 1].phaseHistory;
+    const d0 = Math.abs(h1[0] - h2[0]);
+    const dN = Math.abs(h1[h1.length - 1] - h2[h2.length - 1]);
+    if (d0 > 1e-10 && dN > 1e-10) {
+      sumLog += Math.log(dN / d0) / windowSize;
+      count++;
+    }
+  }
+  return count > 0 ? sumLog / count : 0;
+}
+
+function classifyStability(lyapunovExponent) {
+  if (lyapunovExponent < -0.1) return 'STABLE';
+  if (lyapunovExponent > 0.1) return 'CHAOTIC';
+  return 'MARGINAL';
+}
+
+function adaptiveCoupling(baseCoupling, lyapunovExponent, gain = 0.5) {
+  if (lyapunovExponent < -0.1) return baseCoupling * (1 + gain);
+  if (lyapunovExponent > 0.1) return baseCoupling * (1 - gain);
+  return baseCoupling;
+}
+
+/**
+ * Compute local Lyapunov exponent for a specific oscillator
+ */
+function localLyapunov(oscillator, windowSize = 20) {
+  const history = oscillator.phaseHistory;
+  if (history.length < windowSize + 1) return 0;
+  
+  let sumLog = 0;
+  for (let i = 1; i < windowSize; i++) {
+    const d0 = Math.abs(history[i] - history[i - 1]);
+    if (d0 > 1e-10) {
+      sumLog += Math.log(d0);
+    }
+  }
+  return sumLog / windowSize;
+}
+
+/**
+ * Phase space reconstruction using delay embedding
+ */
+function delayEmbedding(history, embeddingDim = 3, delay = 1) {
+  const embedded = [];
+  for (let i = 0; i < history.length - (embeddingDim - 1) * delay; i++) {
+    const point = [];
+    for (let d = 0; d < embeddingDim; d++) {
+      point.push(history[i + d * delay]);
+    }
+    embedded.push(point);
+  }
+  return embedded;
+}
+
+/**
+ * Stability margin: how far from instability threshold
+ */
+function stabilityMargin(lyapunovExponent, threshold = 0.1) {
+  return threshold - lyapunovExponent;
+}
+
+module.exports = { 
+  estimateLyapunov, 
+  classifyStability, 
+  adaptiveCoupling,
+  localLyapunov,
+  delayEmbedding,
+  stabilityMargin
+};

package/physics/oscillator.js

@@ -0,0 +1,95 @@
+/**
+ * Base class for phase-amplitude oscillator
+ *
+ * Oscillators start QUIESCENT (amplitude = 0) and must be EXCITED
+ * by input to become active. This ensures the field response
+ * reflects the input, not a default full-amplitude state.
+ */
+class Oscillator {
+  constructor(frequency, phase = 0, amplitude = 0) {  // Start quiescent!
+    this.freq = frequency;
+    this.phase = phase;
+    this.amplitude = amplitude;
+    this.baseAmplitude = amplitude;  // Remember initial state
+    this.phaseHistory = [];
+  }
+  
+  tick(dt, coupling = 0) {
+    this.phase = (this.phase + 2 * Math.PI * this.freq * dt + coupling) % (2 * Math.PI);
+    this.phaseHistory.push(this.phase);
+    if (this.phaseHistory.length > 100) this.phaseHistory.shift();
+  }
+  
+  excite(amount = 0.5) {
+    this.amplitude = Math.min(1, this.amplitude + amount);
+  }
+  
+  decay(rate = 0.02, dt = 1) {
+    this.amplitude *= (1 - rate * dt);
+  }
+  
+  getState() {
+    return {
+      freq: this.freq,
+      phase: this.phase,
+      amplitude: this.amplitude
+    };
+  }
+  
+  reset() {
+    this.phase = 0;
+    this.amplitude = 0;  // Reset to quiescent, not full amplitude!
+    this.baseAmplitude = 0;
+    this.phaseHistory = [];
+  }
+}
+
+/**
+ * Collection of coupled oscillators
+ */
+class OscillatorBank {
+  constructor(frequencies) {
+    this.oscillators = frequencies.map(f => new Oscillator(f));
+  }
+  
+  tick(dt, couplingFn) {
+    for (const osc of this.oscillators) {
+      const coupling = couplingFn ? couplingFn(osc, this.oscillators) : 0;
+      osc.tick(dt, coupling);
+    }
+  }
+  
+  exciteByIndices(indices, amount = 0.5) {
+    for (const idx of indices) {
+      if (idx >= 0 && idx < this.oscillators.length) {
+        this.oscillators[idx].excite(amount);
+      }
+    }
+  }
+  
+  decayAll(rate = 0.02, dt = 1) {
+    for (const osc of this.oscillators) {
+      osc.decay(rate, dt);
+    }
+  }
+  
+  getState() {
+    return this.oscillators.map(o => o.getState());
+  }
+  
+  getAmplitudes() {
+    return this.oscillators.map(o => o.amplitude);
+  }
+  
+  getPhases() {
+    return this.oscillators.map(o => o.phase);
+  }
+  
+  reset() {
+    for (const osc of this.oscillators) {
+      osc.reset();
+    }
+  }
+}
+
+module.exports = { Oscillator, OscillatorBank };