@aleph-ai/tinyaleph 1.6.2 → 1.7.1

package/backends/index.js

@@ -9,6 +9,15 @@ import ScientificBackend from './scientific/index.js';
 
 import bioinformatics from './bioinformatics/index.js';
 
+// Named exports for ESM compatibility
+export {
+  Backend,
+  SemanticBackend,
+  CryptographicBackend,
+  ScientificBackend,
+  bioinformatics
+};
+
 export default {
   Backend,
   SemanticBackend,

package/backends/semantic/index.js

@@ -525,10 +525,6 @@ class SemanticBackend extends Backend {
   }
 }
 
-export {
-    SemanticBackend
-};
+export { SemanticBackend };
 
-export default {
-    SemanticBackend
-};
+export default SemanticBackend;

package/core/arithmetic-link-kernel.js

@@ -19,63 +19,7 @@
 'use strict';
 
 import { isPrime, firstNPrimes, factorize } from './prime.js';
-
-// ============================================================================
-// MODULAR EXPONENTIATION UTILITIES
-// ============================================================================
-
-/**
- * Fast modular exponentiation: a^n mod m
- * Uses binary exponentiation for O(log n) complexity
- * 
- * @param {bigint|number} base - Base
- * @param {bigint|number} exp - Exponent
- * @param {bigint|number} mod - Modulus
- * @returns {bigint} Result
- */
-function modPow(base, exp, mod) {
-    base = BigInt(base);
-    exp = BigInt(exp);
-    mod = BigInt(mod);
-    
-    if (mod === 1n) return 0n;
-    
-    let result = 1n;
-    base = base % mod;
-    
-    while (exp > 0n) {
-        if (exp % 2n === 1n) {
-            result = (result * base) % mod;
-        }
-        exp = exp >> 1n;
-        base = (base * base) % mod;
-    }
-    
-    return result;
-}
-
-/**
- * Extended Euclidean Algorithm for modular inverse
- * @param {bigint} a - Number
- * @param {bigint} m - Modulus
- * @returns {bigint} a^(-1) mod m
- */
-function modInverse(a, m) {
-    a = BigInt(a);
-    m = BigInt(m);
-    
-    let [old_r, r] = [a, m];
-    let [old_s, s] = [1n, 0n];
-    
-    while (r !== 0n) {
-        const quotient = old_r / r;
-        [old_r, r] = [r, old_r - quotient * r];
-        [old_s, s] = [s, old_s - quotient * s];
-    }
-    
-    if (old_r > 1n) return null; // No inverse exists
-    return ((old_s % m) + m) % m;
-}
+import { modPowBigInt as modPow, modInverseBigInt as modInverse } from './math-utils.js';
 
 // ============================================================================
 // PHASE 1: PAIRWISE COUPLINGS - Legendre & Power Residue Symbols

package/core/crt-homology.js

@@ -35,46 +35,7 @@
 import { firstNPrimes, isPrime, factorize } from './prime.js';
 import { Complex, PrimeState } from './hilbert.js';
 import { SparsePrimeState, resonanceScore, Quaternion } from './rformer.js';
-
-function extendedGCD(a, b) {
-    if (b === 0) {
-        return { gcd: a, x: 1, y: 0 };
-    }
-    
-    const { gcd, x: x1, y: y1 } = extendedGCD(b, a % b);
-    const x = y1;
-    const y = x1 - Math.floor(a / b) * y1;
-    
-    return { gcd, x, y };
-}
-
-/**
- * Modular multiplicative inverse
- * Returns a^{-1} mod m such that a * a^{-1} ≡ 1 (mod m)
- * @param {number} a - Number to invert
- * @param {number} m - Modulus
- * @returns {number|null} Inverse if exists, null otherwise
- */
-function modInverse(a, m) {
-    a = ((a % m) + m) % m;  // Normalize to positive
-    const { gcd, x } = extendedGCD(a, m);
-    
-    if (gcd !== 1) {
-        return null;  // No inverse exists (not coprime)
-    }
-    
-    return ((x % m) + m) % m;
-}
-
-/**
- * Check if two numbers are coprime
- * @param {number} a - First number
- * @param {number} b - Second number
- * @returns {boolean} True if gcd(a, b) = 1
- */
-function areCoprime(a, b) {
-    return extendedGCD(a, b).gcd === 1;
-}
+import { extendedGCD, modInverse, areCoprime } from './math-utils.js';
 
 /**
  * Softmax function

package/core/hilbert.js

@@ -17,6 +17,7 @@
  * Complex number class for amplitudes
  */
 import { factorize, isPrime, firstNPrimes } from './prime.js';
+import { modPow, modInverse } from './math-utils.js';
 
 class Complex {
   constructor(re = 0, im = 0) {
@@ -1372,21 +1373,7 @@ function findPrimitiveRoot(p) {
   return null;
 }
 
-/**
- * Modular exponentiation: a^b mod m
- */
-function modPow(a, b, m) {
-  let result = 1;
-  a = a % m;
-  while (b > 0) {
-    if (b % 2 === 1) {
-      result = (result * a) % m;
-    }
-    b = Math.floor(b / 2);
-    a = (a * a) % m;
-  }
-  return result;
-}
+// modPow imported from math-utils.js
 
 /**
  * Discrete logarithm: find x such that g^x ≡ n (mod p)
@@ -1419,21 +1406,7 @@ function discreteLog(n, g, p) {
   return -1;  // Not found
 }
 
-/**
- * Modular inverse using extended Euclidean algorithm
- */
-function modInverse(a, m) {
-  let [old_r, r] = [a, m];
-  let [old_s, s] = [1, 0];
-  
-  while (r !== 0) {
-    const q = Math.floor(old_r / r);
-    [old_r, r] = [r, old_r - q * r];
-    [old_s, s] = [s, old_s - q * s];
-  }
-  
-  return ((old_s % m) + m) % m;
-}
+// modInverse imported from math-utils.js
 
 /**
  * Extended Resonance Operators including Möbius and Euler Totient

package/core/hypercomplex.js

@@ -17,11 +17,16 @@ class Hypercomplex {
       throw new Error('Dimension must be power of 2');
     }
     this.dim = dim;
-    this.c = components instanceof Float64Array 
-      ? components 
+    this.c = components instanceof Float64Array
+      ? components
       : new Float64Array(dim);
   }
 
+  // Backward compatibility getter
+  get components() {
+    return this.c;
+  }
+
   // Factory methods
   static zero(dim) { return new Hypercomplex(dim); }
   
@@ -54,6 +59,11 @@ class Hypercomplex {
     return r;
   }
   
+  // Alias for sub()
+  subtract(other) {
+    return this.sub(other);
+  }
+  
   scale(k) {
     const r = new Hypercomplex(this.dim);
     for (let i = 0; i < this.dim; i++) r.c[i] = this.c[i] * k;

package/core/index.js

@@ -114,7 +114,7 @@ import {  Complex,
   findPrimitiveRoot,
   modPow,
   discreteLog,
-  modInverse,
+  modInverse as hilbertModInverse,
   gcd  } from './hilbert.js';
 
 // Golden Ratio Resonance (from symprime symbolic AI)

package/core/math-utils.js

@@ -0,0 +1,259 @@
+/**
+ * Shared Math Utilities for tinyaleph
+ * 
+ * This module provides common mathematical functions used across multiple
+ * core modules to avoid duplicate definitions that cause bundler issues.
+ * 
+ * @module core/math-utils
+ */
+
+// ============================================================================
+// EXTENDED EUCLIDEAN ALGORITHM
+// ============================================================================
+
+/**
+ * Extended Euclidean Algorithm for regular numbers
+ * Returns { gcd, x, y } such that gcd = a*x + b*y
+ * 
+ * @param {number} a - First number
+ * @param {number} b - Second number
+ * @returns {{ gcd: number, x: number, y: number }}
+ */
+export function extendedGCD(a, b) {
+  if (b === 0) {
+    return { gcd: a, x: 1, y: 0 };
+  }
+  
+  const result = extendedGCD(b, a % b);
+  return {
+    gcd: result.gcd,
+    x: result.y,
+    y: result.x - Math.floor(a / b) * result.y
+  };
+}
+
+/**
+ * Extended Euclidean Algorithm for BigInt
+ * Returns { gcd, x, y } such that gcd = a*x + b*y
+ * 
+ * @param {bigint} a - First number
+ * @param {bigint} b - Second number
+ * @returns {{ gcd: bigint, x: bigint, y: bigint }}
+ */
+export function extendedGCDBigInt(a, b) {
+  if (b === 0n) {
+    return { gcd: a, x: 1n, y: 0n };
+  }
+  
+  const result = extendedGCDBigInt(b, a % b);
+  return {
+    gcd: result.gcd,
+    x: result.y,
+    y: result.x - (a / b) * result.y
+  };
+}
+
+// ============================================================================
+// MODULAR INVERSE
+// ============================================================================
+
+/**
+ * Compute modular inverse using Extended Euclidean Algorithm
+ * Works with regular numbers
+ * 
+ * @param {number} a - Number to find inverse of
+ * @param {number} m - Modulus
+ * @returns {number|null} The modular inverse, or null if no inverse exists
+ */
+export function modInverse(a, m) {
+  a = ((a % m) + m) % m;  // Normalize to positive
+  const { gcd, x } = extendedGCD(a, m);
+  
+  if (gcd !== 1) {
+    return null;  // No inverse exists (not coprime)
+  }
+  
+  return ((x % m) + m) % m;
+}
+
+/**
+ * Compute modular inverse for BigInt values
+ * Uses Extended Euclidean Algorithm
+ * 
+ * @param {bigint} a - Number to find inverse of
+ * @param {bigint} m - Modulus
+ * @returns {bigint|null} The modular inverse, or null if no inverse exists
+ */
+export function modInverseBigInt(a, m) {
+  a = BigInt(a);
+  m = BigInt(m);
+  
+  let [old_r, r] = [a, m];
+  let [old_s, s] = [1n, 0n];
+  
+  while (r !== 0n) {
+    const quotient = old_r / r;
+    [old_r, r] = [r, old_r - quotient * r];
+    [old_s, s] = [s, old_s - quotient * s];
+  }
+  
+  if (old_r > 1n) return null; // No inverse exists
+  return ((old_s % m) + m) % m;
+}
+
+// ============================================================================
+// MODULAR EXPONENTIATION
+// ============================================================================
+
+/**
+ * Modular exponentiation for regular numbers
+ * Computes (base^exp) mod m efficiently
+ * 
+ * @param {number} base - Base
+ * @param {number} exp - Exponent
+ * @param {number} m - Modulus
+ * @returns {number} (base^exp) mod m
+ */
+export function modPow(base, exp, m) {
+  if (m === 1) return 0;
+  
+  let result = 1;
+  base = base % m;
+  
+  while (exp > 0) {
+    if (exp % 2 === 1) {
+      result = (result * base) % m;
+    }
+    exp = Math.floor(exp / 2);
+    base = (base * base) % m;
+  }
+  
+  return result;
+}
+
+/**
+ * Modular exponentiation for BigInt
+ * Computes (base^exp) mod m efficiently
+ * 
+ * @param {bigint} base - Base
+ * @param {bigint} exp - Exponent
+ * @param {bigint} m - Modulus
+ * @returns {bigint} (base^exp) mod m
+ */
+export function modPowBigInt(base, exp, m) {
+  if (m === 1n) return 0n;
+  
+  let result = 1n;
+  base = base % m;
+  
+  while (exp > 0n) {
+    if (exp % 2n === 1n) {
+      result = (result * base) % m;
+    }
+    exp = exp / 2n;
+    base = (base * base) % m;
+  }
+  
+  return result;
+}
+
+// ============================================================================
+// COPRIMALITY
+// ============================================================================
+
+/**
+ * Check if two numbers are coprime (gcd = 1)
+ * 
+ * @param {number} a - First number
+ * @param {number} b - Second number
+ * @returns {boolean} True if gcd(a, b) = 1
+ */
+export function areCoprime(a, b) {
+  return extendedGCD(a, b).gcd === 1;
+}
+
+/**
+ * Check if two BigInt numbers are coprime
+ * 
+ * @param {bigint} a - First number
+ * @param {bigint} b - Second number
+ * @returns {boolean} True if gcd(a, b) = 1
+ */
+export function areCoprimeBI(a, b) {
+  return extendedGCDBigInt(a, b).gcd === 1n;
+}
+
+// ============================================================================
+// GCD / LCM
+// ============================================================================
+
+/**
+ * Greatest Common Divisor (regular numbers)
+ * 
+ * @param {number} a - First number
+ * @param {number} b - Second number
+ * @returns {number} GCD of a and b
+ */
+export function gcd(a, b) {
+  return extendedGCD(a, b).gcd;
+}
+
+/**
+ * Greatest Common Divisor (BigInt)
+ * 
+ * @param {bigint} a - First number
+ * @param {bigint} b - Second number
+ * @returns {bigint} GCD of a and b
+ */
+export function gcdBigInt(a, b) {
+  return extendedGCDBigInt(a, b).gcd;
+}
+
+/**
+ * Least Common Multiple (regular numbers)
+ * 
+ * @param {number} a - First number
+ * @param {number} b - Second number
+ * @returns {number} LCM of a and b
+ */
+export function lcm(a, b) {
+  return Math.abs(a * b) / gcd(a, b);
+}
+
+/**
+ * Least Common Multiple (BigInt)
+ * 
+ * @param {bigint} a - First number
+ * @param {bigint} b - Second number
+ * @returns {bigint} LCM of a and b
+ */
+export function lcmBigInt(a, b) {
+  const g = gcdBigInt(a, b);
+  const product = a * b;
+  return product < 0n ? -product / g : product / g;
+}
+
+// Default export with all functions
+export default {
+  // Extended GCD
+  extendedGCD,
+  extendedGCDBigInt,
+  
+  // Modular inverse
+  modInverse,
+  modInverseBigInt,
+  
+  // Modular exponentiation
+  modPow,
+  modPowBigInt,
+  
+  // Coprimality
+  areCoprime,
+  areCoprimeBI,
+  
+  // GCD/LCM
+  gcd,
+  gcdBigInt,
+  lcm,
+  lcmBigInt,
+};

package/engine/index.js

@@ -1,14 +1,56 @@
 /**
- * Engine - exports unified AlephEngine
+ * Engine - exports unified AlephEngine with createEngine factory
  */
 
 import { AlephEngine } from './aleph.js';
 
+// Import all backends for factory
+import SemanticBackend from '../backends/semantic/index.js';
+import ScientificBackend from '../backends/scientific/index.js';
+import CryptographicBackend from '../backends/cryptographic/index.js';
+
+/**
+ * Factory function to create an AlephEngine with specified backend
+ * @param {string} backendType - Backend type: 'semantic', 'quantum', 'scientific', 'cryptographic'
+ * @param {object} [options={}] - Engine and backend options
+ * @returns {AlephEngine} Configured engine instance
+ */
+function createEngine(backendType, options = {}) {
+  let backend;
+  
+  const defaultConfig = {
+    dimension: 16,
+    primes: [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53],
+    ...options.backendConfig
+  };
+  
+  switch (backendType.toLowerCase()) {
+    case 'semantic':
+      backend = new SemanticBackend(defaultConfig);
+      break;
+    case 'quantum':
+    case 'scientific':
+      backend = new ScientificBackend(defaultConfig);
+      break;
+    case 'cryptographic':
+    case 'crypto':
+      backend = new CryptographicBackend(defaultConfig);
+      break;
+    default:
+      // Default to semantic backend
+      backend = new SemanticBackend(defaultConfig);
+  }
+  
+  return new AlephEngine(backend, options.engineConfig || options);
+}
+
 export {
-    AlephEngine
+    AlephEngine,
+    createEngine
 };
 
 // Default export for compatibility with modular.js
 export default {
-    AlephEngine
+    AlephEngine,
+    createEngine
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aleph-ai/tinyaleph",
-  "version": "1.6.2",
+  "version": "1.7.1",
   "description": "Prime-resonant semantic computing framework - hypercomplex algebra, oscillator dynamics, arithmetic topology, and entropy-minimizing reasoning",
   "type": "module",
   "main": "index.js",

package/physics/collapse.js

@@ -4,17 +4,98 @@
 
 import { Hypercomplex } from '../core/hypercomplex.js';
 
-function collapseProbability(entropyIntegral, lyapunovFactor = 1) {
-  const factor = lyapunovFactor < 0 ? 1.5 : 0.5;
-  return (1 - Math.exp(-entropyIntegral)) * factor;
+/**
+ * Calculate collapse probability using Born rule approximation
+ * @param {Hypercomplex|object} state - HypercomplexState or CollapseState object
+ * @param {number} [threshold=0.5] - Collapse threshold
+ * @returns {number} Probability value 0-1
+ */
+function collapseProbability(state, threshold = 0.5) {
+  // Handle CollapseState object with entropy/coherence/lyapunov
+  if (state && typeof state === 'object' && 'entropy' in state) {
+    const { entropy = 0, coherence = 0.5, lyapunov = 0 } = state;
+    const factor = lyapunov < 0 ? 1.5 : 0.5;
+    return (1 - Math.exp(-entropy * coherence)) * factor;
+  }
+  
+  // Handle Hypercomplex state
+  if (state && state.c) {
+    const n = state.norm ? state.norm() : Math.sqrt(state.c.reduce((s, v) => s + v * v, 0));
+    if (n < 1e-10) return 0;
+    
+    // Compute Born-rule probability based on dominant component
+    const probs = state.c.map(v => (v / n) ** 2);
+    const maxProb = Math.max(...probs);
+    return maxProb > threshold ? maxProb : 0;
+  }
+  
+  // Legacy signature: collapseProbability(entropyIntegral, lyapunovFactor)
+  if (typeof state === 'number') {
+    const entropyIntegral = state;
+    const lyapunovFactor = threshold;
+    const factor = lyapunovFactor < 0 ? 1.5 : 0.5;
+    return (1 - Math.exp(-entropyIntegral)) * factor;
+  }
+  
+  return 0;
 }
 
-function shouldCollapse(coherence, entropy, probability, thresholds) {
-  const { minCoherence = 0.7, minEntropy = 1.8 } = thresholds;
-  return coherence > minCoherence && entropy > minEntropy && Math.random() < probability;
+/**
+ * Determine if state should collapse
+ * @param {Hypercomplex|object} state - HypercomplexState or CollapseState
+ * @param {number} threshold - Collapse threshold
+ * @returns {boolean} True if collapse should occur
+ */
+function shouldCollapse(state, threshold = 0.5) {
+  // Handle CollapseState with entropy/coherence
+  if (state && typeof state === 'object' && 'entropy' in state) {
+    const { entropy = 0, coherence = 0.5, lyapunov = 0 } = state;
+    return coherence > threshold && entropy > 1.0 && lyapunov < 0.5;
+  }
+  
+  // Handle Hypercomplex state
+  if (state && state.c) {
+    const prob = collapseProbability(state, threshold);
+    return prob > threshold && Math.random() < prob;
+  }
+  
+  // Legacy signature: shouldCollapse(coherence, entropy, probability, thresholds)
+  if (typeof state === 'number') {
+    const coherence = state;
+    const entropy = threshold;
+    const probability = arguments[2] || 0.5;
+    const thresholds = arguments[3] || {};
+    const { minCoherence = 0.7, minEntropy = 1.8 } = thresholds;
+    return coherence > minCoherence && entropy > minEntropy && Math.random() < probability;
+  }
+  
+  return false;
 }
 
+/**
+ * Measure state and return collapsed index
+ * @param {Hypercomplex} hypercomplex - State to measure
+ * @param {Hypercomplex} [basis=null] - Optional measurement basis
+ * @returns {number} Collapsed index (dominant component index)
+ */
 function measureState(hypercomplex, basis = null) {
+  if (!hypercomplex || !hypercomplex.c) return 0;
+  
+  if (!basis) {
+    let maxIdx = 0, maxVal = 0;
+    for (let i = 0; i < hypercomplex.dim; i++) {
+      const v = Math.abs(hypercomplex.c[i]);
+      if (v > maxVal) { maxVal = v; maxIdx = i; }
+    }
+    return maxIdx;  // Return just the index as a number
+  }
+  return hypercomplex.dot(basis);
+}
+
+/**
+ * Legacy measureState that returns full object
+ */
+function measureStateDetailed(hypercomplex, basis = null) {
   if (!basis) {
     let maxIdx = 0, maxVal = 0;
     for (let i = 0; i < hypercomplex.dim; i++) {
@@ -37,12 +118,26 @@ function collapseToIndex(hypercomplex, index) {
 
 /**
  * Probabilistic measurement with Born rule
+ * @param {Hypercomplex|number[]} hypercomplexOrAmplitudes - State or amplitudes array
+ * @returns {{ index: number, probability: number }} Measurement result
  */
-function bornMeasurement(hypercomplex) {
-  const n = hypercomplex.norm();
-  if (n < 1e-10) return { index: 0, probability: 1 };
+function bornMeasurement(hypercomplexOrAmplitudes) {
+  let probabilities;
+  
+  // Handle plain number array (amplitudes)
+  if (Array.isArray(hypercomplexOrAmplitudes)) {
+    const amplitudes = hypercomplexOrAmplitudes;
+    const sumSq = amplitudes.reduce((s, v) => s + v * v, 0);
+    if (sumSq < 1e-10) return { index: 0, probability: 1 };
+    probabilities = amplitudes.map(v => (v * v) / sumSq);
+  } else {
+    // Handle Hypercomplex object
+    const hypercomplex = hypercomplexOrAmplitudes;
+    const n = hypercomplex.norm ? hypercomplex.norm() : Math.sqrt(hypercomplex.c.reduce((s, v) => s + v * v, 0));
+    if (n < 1e-10) return { index: 0, probability: 1 };
+    probabilities = hypercomplex.c.map(v => (v / n) ** 2);
+  }
   
-  const probabilities = hypercomplex.c.map(v => (v / n) ** 2);
   const r = Math.random();
   let cumulative = 0;