@aleph-ai/tinyaleph 1.0.0

package/modular.js

@@ -0,0 +1,254 @@
+/**
+ * TinyAleph Modular - Main entry point
+ * 
+ * A backend-agnostic prime-based computing framework supporting:
+ * - Semantic Computing (NLP, concept mapping)
+ * - Cryptographic Applications (hashing, key derivation)
+ * - Scientific Computing (quantum simulation, particle physics)
+ */
+
+// Core mathematical foundation
+const core = require('./core');
+const {
+  Hypercomplex,
+  FANO_LINES,
+  octonionMultiplyIndex,
+  sedenionMultiplyIndex,
+  multiplyIndices,
+  buildMultiplicationTable,
+  primeGenerator,
+  nthPrime,
+  primesUpTo,
+  isPrime,
+  factorize,
+  primeSignature,
+  firstNPrimes,
+  GaussianInteger,
+  EisensteinInteger,
+  primeToFrequency,
+  primeToAngle,
+  sumOfTwoSquares,
+  DEFAULT_PRIMES,
+  LLM,
+  // Prime Hilbert Space (HP)
+  Complex,
+  PrimeState,
+  ResonanceOperators,
+  EntropyDrivenEvolution,
+  encodeMemory,
+  symbolicCompute,
+  // Prime Resonance Network
+  PHI,
+  PHI_CONJ,
+  DELTA_S,
+  QuaternionPrime,
+  PrimeResonanceIdentity,
+  PhaseLockedRing,
+  HolographicField,
+  EntangledNode,
+  ResonantFragment,
+  // ResoFormer ML primitives
+  Quaternion,
+  SparsePrimeState,
+  resonanceScore,
+  resonantAttention,
+  hamiltonCompose,
+  measureNonCommutativity,
+  computeCoherence,
+  haltingDecision,
+  coherenceGatedCompute,
+  EntropyCollapseHead,
+  generateAttractorCodebook,
+  PRGraphMemory,
+  applyResonanceOperator
+} = core;
+
+// Physics engine
+const physics = require('./physics');
+const {
+  Oscillator,
+  OscillatorBank,
+  KuramotoModel,
+  shannonEntropy,
+  stateEntropy,
+  coherence,
+  mutualInformation,
+  relativeEntropy,
+  jointEntropy,
+  oscillatorEntropy,
+  estimateLyapunov,
+  classifyStability,
+  adaptiveCoupling,
+  localLyapunov,
+  delayEmbedding,
+  stabilityMargin,
+  collapseProbability,
+  shouldCollapse,
+  measureState,
+  collapseToIndex,
+  bornMeasurement,
+  partialCollapse,
+  applyDecoherence
+} = physics;
+
+// Domain backends
+const backends = require('./backends');
+const {
+  Backend,
+  SemanticBackend,
+  CryptographicBackend,
+  ScientificBackend
+} = backends;
+
+// Unified engine
+const engine = require('./engine');
+const { AlephEngine } = engine;
+
+/**
+ * Factory function to create an engine with a specific backend
+ */
+function createEngine(backendType, config = {}) {
+  let backend;
+  
+  switch (backendType.toLowerCase()) {
+    case 'semantic':
+      backend = new SemanticBackend(config);
+      break;
+    case 'cryptographic':
+    case 'crypto':
+      backend = new CryptographicBackend(config);
+      break;
+    case 'scientific':
+    case 'science':
+    case 'quantum':
+      backend = new ScientificBackend(config);
+      break;
+    default:
+      throw new Error(`Unknown backend type: ${backendType}`);
+  }
+  
+  return new AlephEngine(backend, config.engineOptions || {});
+}
+
+/**
+ * Quick hash function using cryptographic backend
+ */
+function hash(input, length = 32) {
+  const backend = new CryptographicBackend({ dimension: 32 });
+  return backend.hash(input, length);
+}
+
+/**
+ * Quick key derivation
+ */
+function deriveKey(password, salt, length = 32, iterations = 10000) {
+  const backend = new CryptographicBackend({ dimension: 32 });
+  return backend.deriveKey(password, salt, length, iterations);
+}
+
+module.exports = {
+  // Main engine
+  AlephEngine,
+  createEngine,
+  
+  // Backends
+  Backend,
+  SemanticBackend,
+  CryptographicBackend,
+  ScientificBackend,
+  
+  // Core math
+  Hypercomplex,
+  FANO_LINES,
+  octonionMultiplyIndex,
+  sedenionMultiplyIndex,
+  multiplyIndices,
+  buildMultiplicationTable,
+  
+  // Prime utilities
+  primeGenerator,
+  nthPrime,
+  primesUpTo,
+  isPrime,
+  factorize,
+  primeSignature,
+  firstNPrimes,
+  GaussianInteger,
+  EisensteinInteger,
+  primeToFrequency,
+  primeToAngle,
+  sumOfTwoSquares,
+  DEFAULT_PRIMES,
+  
+  // Physics
+  Oscillator,
+  OscillatorBank,
+  KuramotoModel,
+  shannonEntropy,
+  stateEntropy,
+  coherence,
+  mutualInformation,
+  relativeEntropy,
+  jointEntropy,
+  oscillatorEntropy,
+  estimateLyapunov,
+  classifyStability,
+  adaptiveCoupling,
+  localLyapunov,
+  delayEmbedding,
+  stabilityMargin,
+  collapseProbability,
+  shouldCollapse,
+  measureState,
+  collapseToIndex,
+  bornMeasurement,
+  partialCollapse,
+  applyDecoherence,
+  
+  // Convenience functions
+  hash,
+  deriveKey,
+  
+  // LLM client
+  LLM,
+  
+  // Prime Hilbert Space (HP) - Quantum-like prime states
+  Complex,
+  PrimeState,
+  ResonanceOperators,
+  EntropyDrivenEvolution,
+  encodeMemory,
+  symbolicCompute,
+  
+  // Prime Resonance Network - Non-local symbolic computing
+  PHI,
+  PHI_CONJ,
+  DELTA_S,
+  QuaternionPrime,
+  PrimeResonanceIdentity,
+  PhaseLockedRing,
+  HolographicField,
+  EntangledNode,
+  ResonantFragment,
+  
+  // ResoFormer ML Primitives (H_Q = H_P ⊗ ℍ)
+  Quaternion,
+  SparsePrimeState,
+  resonanceScore,
+  resonantAttention,
+  hamiltonCompose,
+  measureNonCommutativity,
+  computeCoherence,
+  haltingDecision,
+  coherenceGatedCompute,
+  EntropyCollapseHead,
+  generateAttractorCodebook,
+  PRGraphMemory,
+  applyResonanceOperator,
+  
+  // Sub-modules
+  core,
+  physics,
+  backends,
+  engine
+};

package/package.json

@@ -0,0 +1,99 @@
+{
+  "name": "@aleph-ai/tinyaleph",
+  "version": "1.0.0",
+  "description": "Prime-resonant semantic computing framework - hypercomplex algebra, oscillator dynamics, and entropy-minimizing reasoning",
+  "main": "index.js",
+  "types": "types/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./index.js",
+      "import": "./index.js",
+      "types": "./types/index.d.ts"
+    },
+    "./core": {
+      "require": "./core/index.js",
+      "import": "./core/index.js"
+    },
+    "./physics": {
+      "require": "./physics/index.js",
+      "import": "./physics/index.js"
+    },
+    "./backends": {
+      "require": "./backends/index.js",
+      "import": "./backends/index.js"
+    },
+    "./engine": {
+      "require": "./engine/index.js",
+      "import": "./engine/index.js"
+    }
+  },
+  "scripts": {
+    "test": "node --test test/*.test.js",
+    "test:legacy": "node test/test-modular.js",
+    "test:queries": "node test/test-queries.js",
+    "test:dna": "node test/test-dna-queries.js",
+    "test:watch": "node --test --watch test/*.test.js",
+    "test:coverage": "node --test --experimental-test-coverage test/*.test.js",
+    "demo": "node examples/demo-modular.js",
+    "demo:two-layer": "node examples/demo-two-layer.js",
+    "benchmark": "node scripts/benchmark.js",
+    "chat": "node examples/chat.js",
+    "train": "node scripts/trainer.js",
+    "examples": "node examples/run-examples.js",
+    "aleph-chat": "node apps/aleph-chat/index.js",
+    "ecdsa-learn": "node apps/ecdsa/index.js"
+  },
+  "keywords": [
+    "semantic-computing",
+    "hypercomplex",
+    "sedenion",
+    "quaternion",
+    "octonion",
+    "prime-numbers",
+    "nlp",
+    "natural-language",
+    "cryptography",
+    "hash",
+    "oscillator",
+    "kuramoto",
+    "entropy",
+    "ai",
+    "machine-learning",
+    "reasoning",
+    "symbolic-ai",
+    "quantum-inspired"
+  ],
+  "author": "Sebastian Schepis",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aleph-ai/tinyaleph.git"
+  },
+  "bugs": {
+    "url": "https://github.com/aleph-ai/tinyaleph/issues"
+  },
+  "homepage": "https://github.com/aleph-ai/tinyaleph#readme",
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "files": [
+    "index.js",
+    "modular.js",
+    "data.json",
+    "core/",
+    "physics/",
+    "backends/",
+    "engine/",
+    "types/",
+    "docs/",
+    "LICENSE",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@noble/curves": "^1.9.7",
+    "@tensorflow/tfjs-node": "^4.22.0"
+  }
+}

package/physics/collapse.js

@@ -0,0 +1,95 @@
+/**
+ * Quantum-inspired state collapse mechanics
+ */
+
+function collapseProbability(entropyIntegral, lyapunovFactor = 1) {
+  const factor = lyapunovFactor < 0 ? 1.5 : 0.5;
+  return (1 - Math.exp(-entropyIntegral)) * factor;
+}
+
+function shouldCollapse(coherence, entropy, probability, thresholds) {
+  const { minCoherence = 0.7, minEntropy = 1.8 } = thresholds;
+  return coherence > minCoherence && entropy > minEntropy && Math.random() < probability;
+}
+
+function measureState(hypercomplex, basis = null) {
+  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 { index: maxIdx, value: hypercomplex.c[maxIdx] };
+  }
+  return hypercomplex.dot(basis);
+}
+
+/**
+ * Collapse state to a specific basis vector
+ */
+function collapseToIndex(hypercomplex, index) {
+  const { Hypercomplex } = require('../core/hypercomplex');
+  const collapsed = Hypercomplex.zero(hypercomplex.dim);
+  collapsed.c[index] = hypercomplex.c[index] >= 0 ? 1 : -1;
+  return collapsed;
+}
+
+/**
+ * Probabilistic measurement with Born rule
+ */
+function bornMeasurement(hypercomplex) {
+  const n = hypercomplex.norm();
+  if (n < 1e-10) return { index: 0, probability: 1 };
+  
+  const probabilities = hypercomplex.c.map(v => (v / n) ** 2);
+  const r = Math.random();
+  let cumulative = 0;
+  
+  for (let i = 0; i < probabilities.length; i++) {
+    cumulative += probabilities[i];
+    if (r < cumulative) {
+      return { index: i, probability: probabilities[i] };
+    }
+  }
+  return { index: probabilities.length - 1, probability: probabilities[probabilities.length - 1] };
+}
+
+/**
+ * Partial collapse: mix between current state and collapsed state
+ */
+function partialCollapse(hypercomplex, targetIndex, strength = 0.5) {
+  const { Hypercomplex } = require('../core/hypercomplex');
+  const collapsed = Hypercomplex.zero(hypercomplex.dim);
+  const sign = hypercomplex.c[targetIndex] >= 0 ? 1 : -1;
+  collapsed.c[targetIndex] = sign;
+  
+  // Linear interpolation between current and collapsed
+  const result = Hypercomplex.zero(hypercomplex.dim);
+  for (let i = 0; i < hypercomplex.dim; i++) {
+    result.c[i] = (1 - strength) * hypercomplex.c[i] + strength * collapsed.c[i];
+  }
+  return result.normalize();
+}
+
+/**
+ * Decoherence: gradual loss of quantum coherence
+ */
+function applyDecoherence(hypercomplex, rate = 0.1) {
+  const { Hypercomplex } = require('../core/hypercomplex');
+  const result = Hypercomplex.zero(hypercomplex.dim);
+  for (let i = 0; i < hypercomplex.dim; i++) {
+    // Add small random noise proportional to rate
+    result.c[i] = hypercomplex.c[i] * (1 - rate) + (Math.random() - 0.5) * rate;
+  }
+  return result.normalize();
+}
+
+module.exports = { 
+  collapseProbability, 
+  shouldCollapse, 
+  measureState,
+  collapseToIndex,
+  bornMeasurement,
+  partialCollapse,
+  applyDecoherence
+};

package/physics/entropy.js

@@ -0,0 +1,88 @@
+/**
+ * Information-theoretic measures for hypercomplex states
+ */
+
+function shannonEntropy(probabilities) {
+  let H = 0;
+  for (const p of probabilities) {
+    if (p > 1e-10) H -= p * Math.log2(p);
+  }
+  return H;
+}
+
+function stateEntropy(hypercomplex) {
+  const n = hypercomplex.norm();
+  if (n < 1e-10) return 0;
+  const probs = hypercomplex.c.map(v => (v / n) ** 2);
+  return shannonEntropy(probs);
+}
+
+function coherence(state1, state2) {
+  const n1 = state1.norm();
+  const n2 = state2.norm();
+  if (n1 < 1e-10 || n2 < 1e-10) return 0;
+  return Math.abs(state1.dot(state2)) / (n1 * n2);
+}
+
+function mutualInformation(bank1, bank2) {
+  let corr = 0;
+  const n = Math.min(bank1.oscillators.length, bank2.oscillators.length);
+  for (let i = 0; i < n; i++) {
+    corr += Math.cos(bank1.oscillators[i].phase - bank2.oscillators[i].phase);
+  }
+  return Math.max(0, corr / n);
+}
+
+/**
+ * Relative entropy (KL divergence) between two probability distributions
+ */
+function relativeEntropy(p, q) {
+  let kl = 0;
+  for (let i = 0; i < p.length; i++) {
+    if (p[i] > 1e-10 && q[i] > 1e-10) {
+      kl += p[i] * Math.log2(p[i] / q[i]);
+    }
+  }
+  return kl;
+}
+
+/**
+ * Joint entropy of two hypercomplex states
+ */
+function jointEntropy(state1, state2) {
+  const n1 = state1.norm();
+  const n2 = state2.norm();
+  if (n1 < 1e-10 || n2 < 1e-10) return 0;
+  
+  // Create joint probability distribution
+  const probs = [];
+  for (let i = 0; i < state1.dim; i++) {
+    for (let j = 0; j < state2.dim; j++) {
+      const p1 = (state1.c[i] / n1) ** 2;
+      const p2 = (state2.c[j] / n2) ** 2;
+      probs.push(p1 * p2);
+    }
+  }
+  return shannonEntropy(probs);
+}
+
+/**
+ * Entropy rate from oscillator bank
+ */
+function oscillatorEntropy(bank) {
+  const amplitudes = bank.getAmplitudes();
+  const total = amplitudes.reduce((a, b) => a + b, 0);
+  if (total < 1e-10) return 0;
+  const probs = amplitudes.map(a => a / total);
+  return shannonEntropy(probs);
+}
+
+module.exports = { 
+  shannonEntropy, 
+  stateEntropy, 
+  coherence, 
+  mutualInformation,
+  relativeEntropy,
+  jointEntropy,
+  oscillatorEntropy
+};

package/physics/index.js

@@ -0,0 +1,65 @@
+/**
+ * Physics engine - exports all physics modules
+ */
+
+const { Oscillator, OscillatorBank } = require('./oscillator');
+const { KuramotoModel } = require('./kuramoto');
+const { 
+  shannonEntropy, 
+  stateEntropy, 
+  coherence, 
+  mutualInformation,
+  relativeEntropy,
+  jointEntropy,
+  oscillatorEntropy
+} = require('./entropy');
+const { 
+  estimateLyapunov, 
+  classifyStability, 
+  adaptiveCoupling,
+  localLyapunov,
+  delayEmbedding,
+  stabilityMargin
+} = require('./lyapunov');
+const { 
+  collapseProbability, 
+  shouldCollapse, 
+  measureState,
+  collapseToIndex,
+  bornMeasurement,
+  partialCollapse,
+  applyDecoherence
+} = require('./collapse');
+
+module.exports = {
+  // Oscillators
+  Oscillator,
+  OscillatorBank,
+  KuramotoModel,
+  
+  // Entropy & Information
+  shannonEntropy,
+  stateEntropy,
+  coherence,
+  mutualInformation,
+  relativeEntropy,
+  jointEntropy,
+  oscillatorEntropy,
+  
+  // Lyapunov stability
+  estimateLyapunov,
+  classifyStability,
+  adaptiveCoupling,
+  localLyapunov,
+  delayEmbedding,
+  stabilityMargin,
+  
+  // State collapse
+  collapseProbability,
+  shouldCollapse,
+  measureState,
+  collapseToIndex,
+  bornMeasurement,
+  partialCollapse,
+  applyDecoherence
+};

package/physics/kuramoto.js

@@ -0,0 +1,91 @@
+/**
+ * Kuramoto synchronization dynamics
+ */
+const { OscillatorBank } = require('./oscillator');
+
+class KuramotoModel extends OscillatorBank {
+  constructor(frequencies, couplingStrength = 0.3) {
+    super(frequencies);
+    this.K = couplingStrength;
+  }
+  
+  orderParameter() {
+    let sx = 0, sy = 0;
+    for (const osc of this.oscillators) {
+      sx += osc.amplitude * Math.cos(osc.phase);
+      sy += osc.amplitude * Math.sin(osc.phase);
+    }
+    const N = this.oscillators.length;
+    return Math.sqrt((sx/N)**2 + (sy/N)**2);
+  }
+  
+  meanPhase() {
+    let sx = 0, sy = 0, ta = 0;
+    for (const osc of this.oscillators) {
+      sx += osc.amplitude * Math.cos(osc.phase);
+      sy += osc.amplitude * Math.sin(osc.phase);
+      ta += osc.amplitude;
+    }
+    return ta > 0 ? Math.atan2(sy/ta, sx/ta) : 0;
+  }
+  
+  kuramotoCoupling(osc) {
+    let coupling = 0;
+    for (const other of this.oscillators) {
+      if (other !== osc) {
+        coupling += Math.sin(other.phase - osc.phase);
+      }
+    }
+    return this.K * coupling / this.oscillators.length;
+  }
+  
+  tick(dt) {
+    super.tick(dt, (osc) => this.kuramotoCoupling(osc) * dt);
+    for (const osc of this.oscillators) {
+      osc.decay(0.02, dt);
+    }
+  }
+  
+  /**
+   * Excite oscillators that correspond to given prime indices
+   */
+  exciteByPrimes(primes, primeList, amount = 0.5) {
+    const primeSet = new Set(primes);
+    for (let i = 0; i < this.oscillators.length && i < primeList.length; i++) {
+      if (primeSet.has(primeList[i])) {
+        this.oscillators[i].excite(amount);
+      }
+    }
+  }
+  
+  /**
+   * Get current state as amplitudes weighted by phase
+   */
+  getWeightedAmplitudes() {
+    return this.oscillators.map(o => o.amplitude * Math.sin(o.phase));
+  }
+  
+  /**
+   * Synchronization measure (0 = desync, 1 = full sync)
+   */
+  synchronization() {
+    return this.orderParameter();
+  }
+  
+  /**
+   * Phase coherence between pairs
+   */
+  pairwiseCoherence() {
+    const N = this.oscillators.length;
+    let total = 0, count = 0;
+    for (let i = 0; i < N; i++) {
+      for (let j = i + 1; j < N; j++) {
+        total += Math.cos(this.oscillators[i].phase - this.oscillators[j].phase);
+        count++;
+      }
+    }
+    return count > 0 ? total / count : 0;
+  }
+}
+
+module.exports = { KuramotoModel };