@aleph-ai/tinyaleph 1.3.0 → 1.4.1

package/core/hilbert.js

@@ -1014,4 +1014,654 @@ module.exports = {
   // Constants
   PHI,
   DELTA_S
-};
+};
+
+// ============================================================================
+// P-ADIC COHERENCE (from Quantum_Semantics paper)
+// ============================================================================
+
+/**
+ * Calculate p-adic norm |x|_p
+ *
+ * For prime p, the p-adic norm of integer x is:
+ * |x|_p = p^(-v_p(x)) where v_p(x) is the largest power of p dividing x
+ *
+ * @param {number} x - Integer value
+ * @param {number} p - Prime number
+ * @returns {number} p-adic norm
+ */
+function pAdicNorm(x, p) {
+  if (x === 0) return 0;
+  
+  let power = 0;
+  let n = Math.abs(Math.floor(x));
+  
+  while (n % p === 0 && n > 0) {
+    power++;
+    n = Math.floor(n / p);
+  }
+  
+  return Math.pow(p, -power);
+}
+
+/**
+ * Calculate p-adic valuation v_p(x)
+ * The highest power of p dividing x
+ *
+ * @param {number} x - Integer value
+ * @param {number} p - Prime number
+ * @returns {number} p-adic valuation
+ */
+function pAdicValuation(x, p) {
+  if (x === 0) return Infinity;
+  
+  let power = 0;
+  let n = Math.abs(Math.floor(x));
+  
+  while (n % p === 0 && n > 0) {
+    power++;
+    n = Math.floor(n / p);
+  }
+  
+  return power;
+}
+
+/**
+ * P-adic coherence between two PrimeStates
+ *
+ * Measures coherence in p-adic metric for each prime p.
+ * From Quantum_Semantics paper: uses p-adic structure for
+ * capturing "closeness" in divisibility sense.
+ *
+ * @param {PrimeState} state1 - First state
+ * @param {PrimeState} state2 - Second state
+ * @param {Array<number>} primes - Primes to compute p-adic coherence for
+ * @returns {Object} p-adic coherence metrics
+ */
+function pAdicCoherence(state1, state2, primes = [2, 3, 5]) {
+  const coherences = {};
+  
+  for (const p of primes) {
+    // Get amplitude magnitudes for this prime in both states
+    const amp1 = state1.get(p);
+    const amp2 = state2.get(p);
+    
+    const mag1 = amp1 ? amp1.norm() : 0;
+    const mag2 = amp2 ? amp2.norm() : 0;
+    
+    // Discretize magnitudes to integers for p-adic comparison
+    const int1 = Math.round(mag1 * 1000);
+    const int2 = Math.round(mag2 * 1000);
+    
+    // p-adic distance: |x - y|_p
+    const diff = Math.abs(int1 - int2);
+    const pNorm = pAdicNorm(diff, p);
+    
+    // Coherence is 1 - normalized p-adic distance
+    // Small p-adic norm (high valuation) means closer in p-adic sense
+    coherences[p] = pNorm < 1e-10 ? 1.0 : Math.exp(-pNorm);
+  }
+  
+  // Overall p-adic coherence (geometric mean)
+  const values = Object.values(coherences);
+  const geometric = Math.pow(
+    values.reduce((prod, v) => prod * Math.max(0.001, v), 1),
+    1 / values.length
+  );
+  
+  return {
+    byPrime: coherences,
+    overall: geometric
+  };
+}
+
+// ============================================================================
+// MÖBIUS AND EULER TOTIENT OPERATORS (from qis.pdf)
+// ============================================================================
+
+/**
+ * Möbius function μ(n)
+ *
+ * μ(n) = 1 if n = 1
+ * μ(n) = (-1)^k if n is product of k distinct primes
+ * μ(n) = 0 if n has squared prime factor
+ *
+ * @param {number} n - Positive integer
+ * @returns {number} Möbius function value
+ */
+function mobiusFunction(n) {
+  if (n === 1) return 1;
+  
+  const { factorize } = require('./prime');
+  const factors = factorize(n);
+  
+  // Check for squared factors
+  for (const exp of Object.values(factors)) {
+    if (exp > 1) return 0;
+  }
+  
+  // Count distinct prime factors
+  const k = Object.keys(factors).length;
+  return Math.pow(-1, k);
+}
+
+/**
+ * Euler's totient function φ(n)
+ *
+ * Counts integers 1 ≤ k ≤ n that are coprime to n.
+ * φ(n) = n · Π(1 - 1/p) for all primes p dividing n
+ *
+ * @param {number} n - Positive integer
+ * @returns {number} Euler totient
+ */
+function eulerTotient(n) {
+  if (n === 1) return 1;
+  
+  const { factorize } = require('./prime');
+  const factors = factorize(n);
+  
+  let result = n;
+  for (const p of Object.keys(factors)) {
+    const prime = parseInt(p);
+    result = result * (1 - 1/prime);
+  }
+  
+  return Math.round(result);
+}
+
+/**
+ * Extended Resonance Operators including Möbius and Euler Totient
+ *
+ * From qis.pdf:
+ * - M̂|n⟩ = μ(n)|n⟩ (Möbius operator)
+ * - Ê|n⟩ = exp(2πiφ(n)/n)|n⟩ (Euler phase operator)
+ */
+const ExtendedOperators = {
+  /**
+   * Möbius Operator: M̂|p⟩ = μ(p)|p⟩
+   * For primes, μ(p) = -1 always
+   *
+   * This operator distinguishes "even" vs "odd" prime products
+   * and annihilates states with squared factors.
+   */
+  M(state) {
+    const result = new PrimeState(state.primes);
+    for (const p of state.primes) {
+      const mu = mobiusFunction(p);
+      result.amplitudes.set(p, state.get(p).scale(mu));
+    }
+    return result;
+  },
+  
+  /**
+   * Euler Phase Operator: Ê|n⟩ = exp(2πiφ(n)/n)|n⟩
+   *
+   * Applies phase rotation based on Euler's totient function.
+   * For prime p: φ(p) = p-1, so phase = 2π(p-1)/p
+   */
+  E(state) {
+    const result = new PrimeState(state.primes);
+    for (const p of state.primes) {
+      const phi = eulerTotient(p);
+      const phase = 2 * Math.PI * phi / p;
+      const rotation = Complex.fromPolar(1, phase);
+      result.amplitudes.set(p, state.get(p).mul(rotation));
+    }
+    return result;
+  },
+  
+  /**
+   * Divisor Count Operator
+   * D̂|n⟩ = d(n)|n⟩ where d(n) is number of divisors
+   */
+  D(state) {
+    const result = new PrimeState(state.primes);
+    for (const p of state.primes) {
+      // For prime p, d(p) = 2
+      result.amplitudes.set(p, state.get(p).scale(2));
+    }
+    return result;
+  },
+  
+  /**
+   * Liouville Operator
+   * L̂|n⟩ = λ(n)|n⟩ where λ(n) = (-1)^Ω(n) (Ω = total prime factors with multiplicity)
+   */
+  L(state) {
+    const result = new PrimeState(state.primes);
+    for (const p of state.primes) {
+      // For prime p, Ω(p) = 1, so λ(p) = -1
+      result.amplitudes.set(p, state.get(p).scale(-1));
+    }
+    return result;
+  }
+};
+
+// ============================================================================
+// KNOWLEDGE RESONANCE Γ_know (from Quantum_Semantics)
+// ============================================================================
+
+/**
+ * Knowledge Resonance Calculator
+ *
+ * From Quantum_Semantics paper: evaluates how conceptual primes align
+ * across a semantic network. Measures coherence of meaning.
+ *
+ * Γ_know = Σ_ij J_ij · R_i · R_j / Σ_i |R_i|²
+ *
+ * Where J_ij are coupling strengths and R_i are resonance values.
+ */
+class KnowledgeResonanceCalculator {
+  /**
+   * @param {Object} options - Configuration
+   */
+  constructor(options = {}) {
+    // Coupling matrix (semantic adjacency)
+    this.couplings = options.couplings || new Map();
+    
+    // Golden ratio for harmonic weighting
+    this.phi = (1 + Math.sqrt(5)) / 2;
+    
+    // Base coupling for unknown pairs
+    this.baseCoupling = options.baseCoupling || 0.1;
+  }
+  
+  /**
+   * Set coupling strength between two concept primes
+   * @param {number} p1 - First prime
+   * @param {number} p2 - Second prime
+   * @param {number} strength - Coupling strength J_ij
+   */
+  setCoupling(p1, p2, strength) {
+    const key = `${Math.min(p1, p2)}:${Math.max(p1, p2)}`;
+    this.couplings.set(key, strength);
+  }
+  
+  /**
+   * Get coupling strength
+   */
+  getCoupling(p1, p2) {
+    const key = `${Math.min(p1, p2)}:${Math.max(p1, p2)}`;
+    if (this.couplings.has(key)) {
+      return this.couplings.get(key);
+    }
+    
+    // Default: coupling based on prime ratio proximity to PHI
+    const ratio = Math.max(p1, p2) / Math.min(p1, p2);
+    const phiDistance = Math.abs(ratio - this.phi);
+    return this.baseCoupling * Math.exp(-phiDistance);
+  }
+  
+  /**
+   * Calculate knowledge resonance for a PrimeState
+   *
+   * @param {PrimeState} state - Concept state
+   * @returns {Object} Resonance metrics
+   */
+  calculate(state) {
+    const primes = state.primes.filter(p => state.get(p).norm() > 1e-10);
+    
+    if (primes.length === 0) {
+      return { gamma: 0, selfEnergy: 0, interactionEnergy: 0 };
+    }
+    
+    // Self-energy: Σ_i |R_i|²
+    let selfEnergy = 0;
+    for (const p of primes) {
+      selfEnergy += state.get(p).norm2();
+    }
+    
+    // Interaction energy: Σ_ij J_ij · R_i · R_j
+    let interactionEnergy = 0;
+    for (let i = 0; i < primes.length; i++) {
+      for (let j = i + 1; j < primes.length; j++) {
+        const J = this.getCoupling(primes[i], primes[j]);
+        const R_i = state.get(primes[i]).norm();
+        const R_j = state.get(primes[j]).norm();
+        interactionEnergy += J * R_i * R_j;
+      }
+    }
+    
+    // Knowledge resonance Γ_know
+    const gamma = selfEnergy > 0
+      ? interactionEnergy / selfEnergy
+      : 0;
+    
+    return {
+      gamma,
+      selfEnergy,
+      interactionEnergy,
+      dominantPrimes: primes.slice(0, 3),
+      coherenceLevel: this.interpretGamma(gamma)
+    };
+  }
+  
+  /**
+   * Interpret gamma value
+   */
+  interpretGamma(gamma) {
+    if (gamma > 0.7) return 'high_coherence';
+    if (gamma > 0.4) return 'moderate_coherence';
+    if (gamma > 0.1) return 'low_coherence';
+    return 'fragmented';
+  }
+  
+  /**
+   * Calculate resonance between two states
+   */
+  resonanceBetween(state1, state2) {
+    // Combined state
+    const combined = state1.add(state2).normalize();
+    const r1 = this.calculate(state1);
+    const r2 = this.calculate(state2);
+    const rCombined = this.calculate(combined);
+    
+    // Synergy: combined > individual sum
+    const synergy = rCombined.gamma - (r1.gamma + r2.gamma) / 2;
+    
+    return {
+      state1Gamma: r1.gamma,
+      state2Gamma: r2.gamma,
+      combinedGamma: rCombined.gamma,
+      synergy,
+      isConstructive: synergy > 0
+    };
+  }
+}
+
+// ============================================================================
+// FIBONACCI WAVELET ALIGNMENT (from Quantum_Semantics)
+// ============================================================================
+
+/**
+ * Fibonacci Wavelet Generator
+ *
+ * Creates wavelets at Fibonacci-scaled frequencies for
+ * multi-resolution semantic analysis.
+ */
+class FibonacciWaveletBank {
+  /**
+   * @param {number} size - Wavelet size
+   * @param {number} scales - Number of Fibonacci scales
+   */
+  constructor(size = 256, scales = 7) {
+    this.size = size;
+    this.phi = (1 + Math.sqrt(5)) / 2;
+    
+    // Generate Fibonacci-scaled wavelets
+    this.wavelets = [];
+    for (let n = -3; n <= scales - 4; n++) {
+      const scale = Math.pow(this.phi, n);
+      this.wavelets.push(this.generateWavelet(scale));
+    }
+  }
+  
+  /**
+   * Generate a Gabor wavelet at given scale
+   * @param {number} scale - Scale factor
+   */
+  generateWavelet(scale) {
+    const wavelet = new Float64Array(this.size);
+    const center = this.size / 2;
+    
+    for (let i = 0; i < this.size; i++) {
+      const t = (i - center) / scale;
+      // Gabor wavelet: cos(t) * exp(-t²/2)
+      wavelet[i] = Math.cos(t) * Math.exp(-t * t / (2 * scale * scale));
+    }
+    
+    return { scale, data: wavelet };
+  }
+  
+  /**
+   * Compute Fibonacci wavelet transform of a signal
+   * @param {Array<number>} signal - Input signal
+   * @returns {Array<Object>} Wavelet coefficients per scale
+   */
+  transform(signal) {
+    const results = [];
+    
+    for (const wavelet of this.wavelets) {
+      const coefficients = this.convolve(signal, wavelet.data);
+      const energy = coefficients.reduce((sum, c) => sum + c * c, 0);
+      
+      results.push({
+        scale: wavelet.scale,
+        coefficients,
+        energy,
+        peak: Math.max(...coefficients.map(Math.abs))
+      });
+    }
+    
+    return results;
+  }
+  
+  /**
+   * Convolution
+   */
+  convolve(signal, kernel) {
+    const output = new Array(signal.length).fill(0);
+    const halfK = Math.floor(kernel.length / 2);
+    
+    for (let i = 0; i < signal.length; i++) {
+      let sum = 0;
+      for (let j = 0; j < kernel.length; j++) {
+        const signalIdx = i + j - halfK;
+        if (signalIdx >= 0 && signalIdx < signal.length) {
+          sum += signal[signalIdx] * kernel[j];
+        }
+      }
+      output[i] = sum;
+    }
+    
+    return output;
+  }
+  
+  /**
+   * Check alignment with Fibonacci sequence
+   * @param {Array<Object>} transformResult - Wavelet transform output
+   */
+  measureAlignment(transformResult) {
+    // Check if energy is concentrated at PHI-related scales
+    const totalEnergy = transformResult.reduce((sum, r) => sum + r.energy, 0);
+    
+    if (totalEnergy < 1e-10) return { aligned: false, score: 0 };
+    
+    // Score based on PHI-power scale concentration
+    let alignedEnergy = 0;
+    for (const result of transformResult) {
+      // Check if scale is close to a PHI power
+      const logScale = Math.log(result.scale) / Math.log(this.phi);
+      const isPhiPower = Math.abs(logScale - Math.round(logScale)) < 0.1;
+      
+      if (isPhiPower) {
+        alignedEnergy += result.energy;
+      }
+    }
+    
+    const score = alignedEnergy / totalEnergy;
+    
+    return {
+      aligned: score > 0.5,
+      score,
+      dominantScale: transformResult.reduce(
+        (max, r) => r.energy > max.energy ? r : max,
+        transformResult[0]
+      ).scale
+    };
+  }
+}
+
+// ============================================================================
+// PATTERN CLASSIFICATION (Zero/Infinity/Fibonacci from Quantum_Semantics)
+// ============================================================================
+
+/**
+ * Semantic Pattern Detector
+ *
+ * Detects fundamental patterns in semantic waves:
+ * - Zero Pattern: convergence/nullification
+ * - Infinity Pattern: divergence/expansion
+ * - Fibonacci Pattern: golden ratio harmony
+ */
+class SemanticPatternDetector {
+  constructor(options = {}) {
+    this.phi = (1 + Math.sqrt(5)) / 2;
+    this.zeroThreshold = options.zeroThreshold || 0.1;
+    this.infinityThreshold = options.infinityThreshold || 5.0;
+    this.fibThreshold = options.fibThreshold || 0.1;
+  }
+  
+  /**
+   * Detect zero pattern (semantic nullification)
+   * Occurs when concepts cancel each other
+   */
+  detectZeroPattern(state) {
+    const entropy = state.entropy();
+    const norm = state.norm();
+    
+    // Zero pattern: high entropy (spread out) + low total amplitude
+    if (norm < this.zeroThreshold) {
+      return {
+        detected: true,
+        strength: 1 - norm / this.zeroThreshold,
+        type: 'convergence'
+      };
+    }
+    
+    // Check for cancellation in pairs
+    let cancellationScore = 0;
+    const primes = state.primes;
+    
+    for (let i = 0; i < primes.length; i++) {
+      for (let j = i + 1; j < primes.length; j++) {
+        const amp1 = state.get(primes[i]);
+        const amp2 = state.get(primes[j]);
+        
+        // Opposite phases with similar magnitudes -> cancellation
+        const phaseDiff = Math.abs(amp1.phase() - amp2.phase());
+        const magRatio = Math.min(amp1.norm(), amp2.norm()) /
+                        (Math.max(amp1.norm(), amp2.norm()) + 1e-10);
+        
+        if (Math.abs(phaseDiff - Math.PI) < 0.3 && magRatio > 0.5) {
+          cancellationScore += magRatio;
+        }
+      }
+    }
+    
+    return {
+      detected: cancellationScore > 1,
+      strength: Math.min(1, cancellationScore / 3),
+      type: 'interference'
+    };
+  }
+  
+  /**
+   * Detect infinity pattern (semantic expansion)
+   * Occurs when concepts reinforce unboundedly
+   */
+  detectInfinityPattern(state) {
+    const amplitudes = state.primes.map(p => state.get(p).norm());
+    const maxAmp = Math.max(...amplitudes);
+    const meanAmp = amplitudes.reduce((s, a) => s + a, 0) / amplitudes.length;
+    
+    // Infinity pattern: one or few primes dominate strongly
+    const dominanceRatio = maxAmp / (meanAmp + 1e-10);
+    
+    if (dominanceRatio > this.infinityThreshold) {
+      return {
+        detected: true,
+        strength: Math.min(1, dominanceRatio / 10),
+        type: 'divergence',
+        dominantPrime: state.dominant(1)[0].p
+      };
+    }
+    
+    return { detected: false, strength: 0, type: 'stable' };
+  }
+  
+  /**
+   * Detect Fibonacci/Golden pattern
+   * Occurs when amplitude ratios approximate PHI
+   */
+  detectFibonacciPattern(state) {
+    const primes = state.primes.filter(p => state.get(p).norm() > 0.01);
+    if (primes.length < 2) {
+      return { detected: false, score: 0 };
+    }
+    
+    // Sort by amplitude
+    const sorted = primes
+      .map(p => ({ p, amp: state.get(p).norm() }))
+      .sort((a, b) => b.amp - a.amp);
+    
+    // Check consecutive amplitude ratios for PHI
+    let phiCount = 0;
+    let totalPairs = 0;
+    
+    for (let i = 0; i < sorted.length - 1; i++) {
+      const ratio = sorted[i].amp / (sorted[i + 1].amp + 1e-10);
+      const phiDistance = Math.abs(ratio - this.phi);
+      
+      if (phiDistance < this.fibThreshold) {
+        phiCount++;
+      }
+      totalPairs++;
+    }
+    
+    const score = totalPairs > 0 ? phiCount / totalPairs : 0;
+    
+    return {
+      detected: score > 0.3,
+      score,
+      phiRatioCount: phiCount,
+      dominantPair: sorted.length >= 2
+        ? [sorted[0].p, sorted[1].p]
+        : null
+    };
+  }
+  
+  /**
+   * Full pattern classification
+   */
+  classify(state) {
+    const zero = this.detectZeroPattern(state);
+    const infinity = this.detectInfinityPattern(state);
+    const fib = this.detectFibonacciPattern(state);
+    
+    // Determine dominant pattern
+    let dominant = 'neutral';
+    let confidence = 0;
+    
+    if (zero.detected && zero.strength > confidence) {
+      dominant = 'zero';
+      confidence = zero.strength;
+    }
+    if (infinity.detected && infinity.strength > confidence) {
+      dominant = 'infinity';
+      confidence = infinity.strength;
+    }
+    if (fib.detected && fib.score > confidence) {
+      dominant = 'fibonacci';
+      confidence = fib.score;
+    }
+    
+    return {
+      dominant,
+      confidence,
+      patterns: { zero, infinity, fibonacci: fib },
+      entropy: state.entropy()
+    };
+  }
+}
+
+// Export new classes and functions
+module.exports.pAdicNorm = pAdicNorm;
+module.exports.pAdicValuation = pAdicValuation;
+module.exports.pAdicCoherence = pAdicCoherence;
+module.exports.mobiusFunction = mobiusFunction;
+module.exports.eulerTotient = eulerTotient;
+module.exports.ExtendedOperators = ExtendedOperators;
+module.exports.KnowledgeResonanceCalculator = KnowledgeResonanceCalculator;
+module.exports.FibonacciWaveletBank = FibonacciWaveletBank;
+module.exports.SemanticPatternDetector = SemanticPatternDetector;