@aleph-ai/tinyaleph 1.6.2 → 1.7.1

package/physics/fiber-bundle.js

@@ -0,0 +1,207 @@
+/**
+ * Quantum Fiber Bundle Theory
+ * 
+ * Implements the geometric structure for state evolution and protection:
+ * - Principal Bundle Framework (Base manifold M, Total space P)
+ * - Berry Connection & Curvature
+ * - Holonomy Operator for path-dependent memory
+ * - Chern Classes for topological invariants
+ * 
+ * Based on 01_FIBER_BUNDLES.md
+ */
+
+import { Complex, normalizeComplex } from './primeon_z_ladder_u.js';
+
+/**
+ * Represents a point in the Base Manifold M (Configuration Space)
+ */
+class ManifoldPoint {
+  constructor(coordinates) {
+    this.coordinates = coordinates; // Array of numbers
+  }
+
+  distance(other) {
+    return Math.sqrt(this.coordinates.reduce((sum, val, i) => sum + Math.pow(val - other.coordinates[i], 2), 0));
+  }
+}
+
+/**
+ * Geometric Phase Tracker using Berry Connection
+ */
+class BerryConnection {
+  constructor(dimension) {
+    this.dimension = dimension;
+    this.history = [];
+  }
+
+  /**
+   * Calculate local connection 1-form: A = i⟨ψ|d|ψ⟩
+   * @param {Complex[]} psi Current state vector
+   * @param {Complex[]} d_psi Change in state vector
+   * @returns {Complex} Connection value
+   */
+  calculateConnection(psi, d_psi) {
+    // Inner product ⟨ψ|d|ψ⟩
+    let inner = new Complex(0, 0);
+    for (let i = 0; i < psi.length; i++) {
+      // ⟨ψ| is conjugate
+      const bra = Complex.conj(psi[i]);
+      const term = Complex.mul(bra, d_psi[i]);
+      inner = Complex.add(inner, term);
+    }
+    
+    // A = i * inner
+    return Complex.mul(new Complex(0, 1), inner);
+  }
+
+  /**
+   * Calculate Berry Curvature 2-form: F_μν = ∂_μA_ν - ∂_νA_μ - i[A_μ,A_ν]
+   * Simplified for abelian U(1) case: F = dA
+   * @param {Complex} A_mu Connection in direction mu
+   * @param {Complex} A_nu Connection in direction nu
+   * @param {number} d_mu Step size in mu
+   * @param {number} d_nu Step size in nu
+   */
+  calculateCurvature(A_mu, A_nu, d_mu, d_nu) {
+    // Approximation of dA
+    const dA = Complex.sub(A_nu, A_mu);
+    return Complex.scale(dA, 1 / (d_mu * d_nu)); // Simplified numerical derivative
+  }
+}
+
+/**
+ * Holonomy Operator for Path-Dependent Memory
+ * U(C) = P exp(-i∮_C A_μdR^μ)
+ */
+class HolonomyOperator {
+  constructor() {
+    this.phase = new Complex(1, 0); // Start with identity
+    this.pathIntegral = new Complex(0, 0);
+  }
+
+  /**
+   * Update holonomy along a path segment
+   * @param {Complex} connection Local Berry connection A
+   * @param {number} stepSize Path segment length dR
+   */
+  transport(connection, stepSize) {
+    // Integral accumulation: ∫ A dR
+    const term = Complex.scale(connection, stepSize);
+    this.pathIntegral = Complex.add(this.pathIntegral, term);
+    
+    // U = exp(-i * integral)
+    const phaseArg = -1 * this.pathIntegral.re; // simplified for U(1) real phase
+    // In full SU(N) this would be matrix exponential
+    
+    // Update phase factor
+    // Note: A is imaginary-valued for normalized states, so -i*A is real
+    // If A = i*a, then -i*A = a.
+    // For general complex A:
+    const exponent = Complex.mul(new Complex(0, -1), term);
+    this.phase = Complex.mul(this.phase, Complex.exp(exponent.re)); // Approximation
+  }
+  
+  /**
+   * Get current holonomy factor
+   */
+  getFactor() {
+    return this.phase;
+  }
+  
+  reset() {
+    this.phase = new Complex(1, 0);
+    this.pathIntegral = new Complex(0, 0);
+  }
+}
+
+/**
+ * Topological Protection via Chern Classes
+ */
+class TopologicalProtection {
+  constructor() {
+    this.chernNumber = 0;
+  }
+
+  /**
+   * Calculate First Chern Class c1 = 1/2π tr(F)
+   * @param {Complex} curvature Berry curvature F
+   */
+  calculateChernClass(curvature) {
+    // For U(1), trace is just the value
+    // c1 = F / 2π
+    // Taking imaginary part as F should be purely imaginary for unitary evolution
+    return curvature.im / (2 * Math.PI);
+  }
+
+  /**
+   * Integrate Chern class over manifold to get Chern number
+   * @param {Complex[]} curvatures Array of curvature values over the manifold
+   */
+  computeChernNumber(curvatures) {
+    let sum = 0;
+    for (const F of curvatures) {
+      sum += this.calculateChernClass(F);
+    }
+    // Chern number should be an integer for closed manifolds
+    this.chernNumber = Math.round(sum);
+    return this.chernNumber;
+  }
+
+  /**
+   * Check if state is topologically protected (non-zero Chern number)
+   */
+  isProtected() {
+    return this.chernNumber !== 0;
+  }
+}
+
+/**
+ * Fiber Bundle Manager
+ * Orchestrates the geometric components
+ */
+class FiberBundle {
+  constructor(dimension) {
+    this.dimension = dimension;
+    this.connection = new BerryConnection(dimension);
+    this.holonomy = new HolonomyOperator();
+    this.topology = new TopologicalProtection();
+    this.currentState = null;
+  }
+
+  /**
+   * Evolve state and update geometric factors
+   * @param {Complex[]} newState New state vector
+   * @param {number} stepSize Distance moved in parameter space
+   */
+  evolve(newState, stepSize = 0.01) {
+    if (!this.currentState) {
+      this.currentState = newState;
+      return;
+    }
+
+    // Calculate change d|ψ⟩
+    const d_psi = newState.map((v, i) => Complex.sub(v, this.currentState[i]));
+    
+    // Calculate Connection A
+    const A = this.connection.calculateConnection(this.currentState, d_psi);
+    
+    // Update Holonomy
+    this.holonomy.transport(A, stepSize);
+    
+    // Update state
+    this.currentState = newState;
+    
+    return {
+      connection: A,
+      holonomy: this.holonomy.getFactor()
+    };
+  }
+}
+
+export {
+  ManifoldPoint,
+  BerryConnection,
+  HolonomyOperator,
+  TopologicalProtection,
+  FiberBundle
+};

package/physics/kuramoto.js

@@ -5,9 +5,39 @@
 import { OscillatorBank } from './oscillator.js';
 
 class KuramotoModel extends OscillatorBank {
-  constructor(frequencies, couplingStrength = 0.3) {
-    super(frequencies);
-    this.K = couplingStrength;
+  /**
+   * Create a Kuramoto synchronization model
+   * @param {number[]|OscillatorBank} frequenciesOrBank - Array of frequencies or an existing OscillatorBank
+   * @param {number|object} [couplingOrOptions=0.3] - Coupling strength (number) or options object
+   */
+  constructor(frequenciesOrBank, couplingOrOptions = 0.3) {
+    if (frequenciesOrBank instanceof OscillatorBank) {
+      // Use existing OscillatorBank's oscillators
+      super([]);  // Initialize with empty array
+      this.oscillators = frequenciesOrBank.oscillators;
+      this.primeList = frequenciesOrBank.primeList || frequenciesOrBank.oscillators.map(o => o.freq);
+      
+      // Parse options
+      if (typeof couplingOrOptions === 'object') {
+        this.K = couplingOrOptions.coupling ?? 0.3;
+      } else {
+        this.K = couplingOrOptions;
+      }
+    } else {
+      // Traditional constructor with frequencies array
+      super(frequenciesOrBank);
+      this.K = typeof couplingOrOptions === 'object'
+        ? (couplingOrOptions.coupling ?? 0.3)
+        : couplingOrOptions;
+    }
+  }
+  
+  /**
+   * Single step forward in time
+   * @param {number} dt - Timestep
+   */
+  step(dt) {
+    this.tick(dt);
   }
   
   orderParameter() {

package/physics/lyapunov.js

@@ -2,7 +2,24 @@
  * Lyapunov exponent estimation from phase histories
  */
 
-function estimateLyapunov(oscillators, windowSize = 20) {
+/**
+ * Estimate Lyapunov exponent from time series or oscillators
+ * @param {number[]|object[]} historyOrOscillators - Time series array or oscillator objects
+ * @param {number} [windowSize=20] - Window size for computation
+ * @returns {number} Estimated Lyapunov exponent
+ */
+function estimateLyapunov(historyOrOscillators, windowSize = 20) {
+  // Handle both signatures: number[] (time series) or oscillator objects
+  if (!historyOrOscillators || historyOrOscillators.length === 0) return 0;
+  
+  // Check if input is a raw number array (time series)
+  if (typeof historyOrOscillators[0] === 'number') {
+    return estimateLyapunovFromTimeSeries(historyOrOscillators, windowSize);
+  }
+  
+  // Otherwise treat as oscillator objects
+  const oscillators = historyOrOscillators;
+  if (!oscillators[0] || !oscillators[0].phaseHistory) return 0;
   if (oscillators[0].phaseHistory.length < windowSize) return 0;
   
   let sumLog = 0, count = 0;
@@ -19,13 +36,92 @@ function estimateLyapunov(oscillators, windowSize = 20) {
   return count > 0 ? sumLog / count : 0;
 }
 
+/**
+ * Estimate Lyapunov exponent from a time series (number array)
+ * Uses the Rosenstein algorithm approximation
+ * @param {number[]} history - Time series data
+ * @param {number} [windowSize=20] - Window size
+ * @returns {number} Estimated Lyapunov exponent
+ */
+function estimateLyapunovFromTimeSeries(history, windowSize = 20) {
+  if (history.length < windowSize + 1) return 0;
+  
+  let sumLog = 0;
+  let count = 0;
+  
+  // Compute average log divergence over window
+  for (let i = 1; i < Math.min(history.length, windowSize); i++) {
+    const d0 = Math.abs(history[i] - history[i - 1]);
+    if (d0 > 1e-10) {
+      // Find nearby point and track divergence
+      const neighbors = [];
+      for (let j = 0; j < history.length; j++) {
+        if (Math.abs(j - i) > 1) {
+          const dist = Math.abs(history[j] - history[i]);
+          if (dist > 1e-10 && dist < 0.5) {
+            neighbors.push({ j, dist });
+          }
+        }
+      }
+      
+      if (neighbors.length > 0) {
+        neighbors.sort((a, b) => a.dist - b.dist);
+        const nearIdx = neighbors[0].j;
+        const initialDist = neighbors[0].dist;
+        
+        // Track divergence
+        const evolvedDist = Math.abs(
+          history[Math.min(i + windowSize, history.length - 1)] -
+          history[Math.min(nearIdx + windowSize, history.length - 1)]
+        );
+        
+        if (evolvedDist > 1e-10) {
+          sumLog += Math.log(evolvedDist / initialDist) / windowSize;
+          count++;
+        }
+      }
+    }
+  }
+  
+  return count > 0 ? sumLog / count : 0;
+}
+
+/**
+ * Classify stability based on Lyapunov exponent
+ * @param {number} lyapunovExponent - The Lyapunov exponent
+ * @returns {'stable'|'unstable'|'chaotic'|'collapsed'} Stability classification
+ */
 function classifyStability(lyapunovExponent) {
-  if (lyapunovExponent < -0.1) return 'STABLE';
-  if (lyapunovExponent > 0.1) return 'CHAOTIC';
-  return 'MARGINAL';
+  if (lyapunovExponent < -0.1) return 'collapsed';  // Strong convergence
+  if (lyapunovExponent < 0) return 'stable';         // Weak convergence
+  if (lyapunovExponent < 0.5) return 'unstable';    // Weak divergence
+  return 'chaotic';                                   // Strong divergence
 }
 
-function adaptiveCoupling(baseCoupling, lyapunovExponent, gain = 0.5) {
+/**
+ * Compute adaptive coupling strength based on coherence or Lyapunov exponent
+ * @param {number} coherenceOrBase - Coherence value (0-1) or base coupling strength
+ * @param {number} [baseStrengthOrLyapunov=0.3] - Base strength (for coherence mode) or Lyapunov exponent
+ * @param {number} [gain=0.5] - Gain factor for legacy mode
+ * @returns {number} Adapted coupling strength
+ */
+function adaptiveCoupling(coherenceOrBase, baseStrengthOrLyapunov = 0.3, gain = 0.5) {
+  // If first arg is between 0 and 1 and second is small, treat as coherence mode
+  // adaptiveCoupling(coherence, baseStrength?)
+  if (coherenceOrBase >= 0 && coherenceOrBase <= 1 &&
+      (baseStrengthOrLyapunov >= 0.05 && baseStrengthOrLyapunov <= 1)) {
+    const coherence = coherenceOrBase;
+    const baseStrength = baseStrengthOrLyapunov;
+    
+    // High coherence = stronger coupling, low coherence = weaker coupling
+    // Scale coupling between 0.5x and 1.5x base strength based on coherence
+    return baseStrength * (0.5 + coherence);
+  }
+  
+  // Legacy mode: adaptiveCoupling(baseCoupling, lyapunovExponent, gain?)
+  const baseCoupling = coherenceOrBase;
+  const lyapunovExponent = baseStrengthOrLyapunov;
+  
   if (lyapunovExponent < -0.1) return baseCoupling * (1 + gain);
   if (lyapunovExponent > 0.1) return baseCoupling * (1 - gain);
   return baseCoupling;

package/physics/oscillator.js

@@ -49,8 +49,39 @@ class Oscillator {
  * Collection of coupled oscillators
  */
 class OscillatorBank {
-  constructor(frequencies) {
-    this.oscillators = frequencies.map(f => new Oscillator(f));
+  /**
+   * Create an OscillatorBank
+   * @param {number|number[]} sizeOrFrequencies - Either a number (size) or array of frequencies
+   * @param {number[]} [defaultPrimes] - Optional default primes for size-based construction
+   */
+  constructor(sizeOrFrequencies, defaultPrimes = null) {
+    if (typeof sizeOrFrequencies === 'number') {
+      // Size-based constructor: create oscillators with first N primes as frequencies
+      const primes = defaultPrimes || this._generatePrimes(sizeOrFrequencies);
+      this.oscillators = primes.slice(0, sizeOrFrequencies).map(p => new Oscillator(p));
+      this.primeList = primes.slice(0, sizeOrFrequencies);
+    } else {
+      // Frequency array constructor
+      this.oscillators = sizeOrFrequencies.map(f => new Oscillator(f));
+      this.primeList = sizeOrFrequencies;
+    }
+  }
+  
+  /**
+   * Generate first N primes (helper)
+   */
+  _generatePrimes(n) {
+    const primes = [];
+    let num = 2;
+    while (primes.length < n) {
+      let isPrime = true;
+      for (let i = 2; i <= Math.sqrt(num); i++) {
+        if (num % i === 0) { isPrime = false; break; }
+      }
+      if (isPrime) primes.push(num);
+      num++;
+    }
+    return primes;
   }
   
   tick(dt, couplingFn) {
@@ -68,6 +99,21 @@ class OscillatorBank {
     }
   }
   
+  /**
+   * Excite oscillators based on prime frequencies
+   * @param {number[]} primes - Array of prime numbers to excite
+   * @param {number} [amount=0.5] - Excitation amount
+   */
+  excite(primes, amount = 0.5) {
+    const primeSet = new Set(primes);
+    for (let i = 0; i < this.oscillators.length; i++) {
+      // Match by prime frequency
+      if (primeSet.has(this.primeList[i]) || primeSet.has(this.oscillators[i].freq)) {
+        this.oscillators[i].excite(amount);
+      }
+    }
+  }
+  
   decayAll(rate = 0.02, dt = 1) {
     for (const osc of this.oscillators) {
       osc.decay(rate, dt);

package/physics/primeon_z_ladder_u.js

@@ -488,5 +488,7 @@ export {
     shannonEntropyNats,
     probsOf,
     normalize,
-    C
+    normalize as normalizeComplex,
+    C,
+    C as Complex
 };

package/physics/quantum-hash.js

@@ -0,0 +1,139 @@
+/**
+ * Quantum Hash Topology
+ * 
+ * Implements Quantum Hash functions and topological analysis:
+ * - Quantum Round Function
+ * - Linearity Measures
+ * - Collision Detection via Interference
+ * - Topological Protection
+ * 
+ * Based on 04_QUANTUM_HASH.md
+ */
+
+import { Complex, normalizeComplex } from './primeon_z_ladder_u.js';
+
+/**
+ * Quantum Hash Function Core
+ */
+class QuantumHash {
+  constructor(bitWidth = 32) {
+    this.bitWidth = bitWidth;
+    this.N = Math.pow(2, bitWidth);
+  }
+
+  /**
+   * Classical Hash Function placeholder (e.g., simplified SHA-like)
+   * @param {number} x Input
+   * @returns {number} Hash output
+   */
+  classicalHash(x) {
+    // Simple mixing for demo
+    let h = x * 0x45d9f3b;
+    h = ((h >>> 16) ^ h) * 0x45d9f3b;
+    h = ((h >>> 16) ^ h);
+    return h >>> 0; // Ensure unsigned 32-bit
+  }
+
+  /**
+   * Quantum Round Function
+   * R_q: |x⟩ → 1/√2(|f(x)⟩ + i|f(x⊕k)⟩)
+   * Creates superposition of hash of x and hash of x XOR k
+   */
+  roundFunction(x, k) {
+    const fx = this.classicalHash(x);
+    const fxk = this.classicalHash(x ^ k);
+    
+    const state = [
+      { val: fx, amp: new Complex(1/Math.sqrt(2), 0) },
+      { val: fxk, amp: new Complex(0, 1/Math.sqrt(2)) }
+    ];
+    
+    return state;
+  }
+
+  /**
+   * Linearity Measure
+   * L(f) = Pr[f(x⊕y) = f(x)⊕f(y)]
+   * Assesses resistance to differential attacks
+   */
+  measureLinearity(samples = 100) {
+    let matches = 0;
+    
+    for (let i = 0; i < samples; i++) {
+      const x = Math.floor(Math.random() * this.N);
+      const y = Math.floor(Math.random() * this.N);
+      
+      const f_xy = this.classicalHash(x ^ y);
+      const fx_fy = this.classicalHash(x) ^ this.classicalHash(y);
+      
+      if (f_xy === fx_fy) {
+        matches++;
+      }
+    }
+    
+    return matches / samples;
+  }
+}
+
+/**
+ * Collision Detection using Quantum Interference
+ */
+class CollisionDetector {
+  constructor(hashFunction) {
+    this.hash = hashFunction;
+  }
+
+  /**
+   * Detect Collision Amplitude
+   * |ψ_c⟩ = 1/√N ∑_{x,y} |x,y⟩|H(x)⊕H(y)⟩
+   * 
+   * Simplified simulation of collision search
+   */
+  detectCollision(targetHash, maxSteps = 1000) {
+    // Grover-like search simulation
+    // In a real quantum computer, this amplifies amplitude of solution
+    
+    // Classical simulation of the "Interference" check
+    // I(x,y) = |⟨H(x)|H(y)⟩|²
+    
+    for (let i = 0; i < maxSteps; i++) {
+      const x = Math.floor(Math.random() * this.hash.N);
+      const hx = this.hash.classicalHash(x);
+      
+      // Check for collision (constructive interference)
+      if (hx === targetHash) {
+        return { found: true, preimage: x, steps: i };
+      }
+    }
+    
+    return { found: false, steps: maxSteps };
+  }
+}
+
+/**
+ * Topological Protection for Hash States
+ */
+class HashTopology {
+  constructor() {
+    this.connection = new Complex(0, 0);
+  }
+
+  /**
+   * Modified Connection Form
+   * A_H = A + H(x)dx
+   */
+  updateConnection(baseConnection, hashValue, stepSize) {
+    // H(x) contribution
+    // Map hash to phase/amplitude
+    const hashTerm = new Complex(hashValue * 1e-9, 0); // Scale down
+    const term = Complex.scale(hashTerm, stepSize);
+    
+    return Complex.add(baseConnection, term);
+  }
+}
+
+export {
+  QuantumHash,
+  CollisionDetector,
+  HashTopology
+};