@aleph-ai/tinyaleph 1.5.7 → 1.6.1

package/examples/oracle-demo.js

@@ -0,0 +1,204 @@
+/**
+ * book.pdf Chapters 10 & 11: Oracle Systems & NP Resonance Demo
+ * 
+ * Demonstrates:
+ * - Oracle Q: (S, ε) → R_stable with I-Ching attractors
+ * - Divination queries
+ * - SAT solving via resonance collapse
+ * - Semantic compression
+ */
+
+import { PrimeState } from '../core/hilbert.js';
+import { 
+  OracleSystem, 
+  HexagramAttractor,
+  NPResonanceEncoder,
+  SemanticCompressor,
+  HEXAGRAMS
+} from '../core/oracle.js';
+
+console.log('═══════════════════════════════════════════════════════════════');
+console.log('  book.pdf Chapters 10 & 11: Oracle & NP Systems Demo');
+console.log('═══════════════════════════════════════════════════════════════\n');
+
+// ==========================================================================
+// 1. I-Ching Hexagram Attractors
+// ==========================================================================
+console.log('1. I-Ching Hexagram Attractors');
+console.log('   64 hexagrams as stable resonance basins\n');
+
+console.log('   Sample hexagrams:');
+[1, 2, 11, 12, 63, 64].forEach(num => {
+  const hex = HEXAGRAMS[num];
+  if (hex) {
+    console.log(`      ${num}. ${hex.name} (${hex.meaning})`);
+    console.log(`         Binary: ${hex.binary.toString(2).padStart(6, '0')}, Primes: [${hex.primes.join(', ')}]`);
+  }
+});
+
+// Create attractor and show its state
+const attractor = new HexagramAttractor(11); // Tài - Peace
+console.log(`\n   Attractor for Hexagram 11 (Tài - Peace):`);
+console.log(`   Dominant primes: ${attractor.state.dominant(3).map(d => `${d.p}: ${d.amp.toFixed(3)}`).join(', ')}`);
+
+// ==========================================================================
+// 2. Oracle System Q: (S, ε) → R_stable
+// ==========================================================================
+console.log('\n2. Oracle System Q: (S, ε) → R_stable');
+console.log('   Entropy-modulated evolution to stable attractors\n');
+
+const oracle = new OracleSystem({ 
+  maxIterations: 50,
+  convergenceThreshold: 0.01 
+});
+
+// Query with a semantic state
+const queries = [
+  'love and harmony',
+  'conflict and struggle', 
+  'new beginnings',
+  'patience and waiting'
+];
+
+console.log('   Oracle queries:');
+for (const query of queries) {
+  const result = oracle.query(query);
+  console.log(`\n   "${query}"`);
+  console.log(`      → Attractor: ${result.attractor.number}. ${result.attractor.name}`);
+  console.log(`        Meaning: ${result.attractor.meaning}`);
+  console.log(`        Converged: ${result.converged} in ${result.iterations} iterations`);
+  console.log(`        Final entropy: ${result.finalEntropy.toFixed(4)}`);
+}
+
+// ==========================================================================
+// 3. Divination Query
+// ==========================================================================
+console.log('\n\n3. Divination Query with I-Ching Interpretation');
+console.log('   oracle.divine(question) → hexagram + interpretation\n');
+
+const divination = oracle.divine('Should I take a new path?');
+console.log(`   Question: "${divination.question}"`);
+console.log(`   Answer: Hexagram ${divination.attractor.number} - ${divination.attractor.name}`);
+console.log(`   Meaning: ${divination.attractor.meaning}`);
+console.log(`   Primes: [${divination.attractor.primes.join(', ')}]`);
+console.log(`   Iterations: ${divination.iterations}, Converged: ${divination.converged}`);
+
+// ==========================================================================
+// 4. NP Resonance Encoder - SAT Solving
+// ==========================================================================
+console.log('\n\n4. NP Resonance Encoder: V̂_NP = Π_j Ĉ_j');
+console.log('   SAT solving via clause-resonance projection and collapse\n');
+
+// Create a simple SAT problem: (x1 OR x2) AND (NOT x1 OR x3) AND (NOT x2 OR NOT x3)
+const sat = new NPResonanceEncoder(['x1', 'x2', 'x3']);
+
+sat.addClause([{ var: 'x1', negated: false }, { var: 'x2', negated: false }]);   // x1 OR x2
+sat.addClause([{ var: 'x1', negated: true }, { var: 'x3', negated: false }]);    // NOT x1 OR x3
+sat.addClause([{ var: 'x2', negated: true }, { var: 'x3', negated: true }]);     // NOT x2 OR NOT x3
+
+console.log('   SAT Problem:');
+console.log('      (x1 OR x2) AND (NOT x1 OR x3) AND (NOT x2 OR NOT x3)\n');
+
+// Solve
+const solution = sat.solve(50);
+console.log('   Solution:');
+console.log(`      Satisfiable: ${solution.satisfiable}`);
+if (solution.assignment) {
+  console.log(`      Assignment: ${JSON.stringify(solution.assignment)}`);
+}
+console.log(`      Iterations: ${solution.iterations}`);
+console.log(`      Confidence: ${(solution.confidence * 100).toFixed(1)}%`);
+
+// Verify solution manually
+if (solution.assignment) {
+  const { x1, x2, x3 } = solution.assignment;
+  const c1 = x1 || x2;
+  const c2 = !x1 || x3;
+  const c3 = !x2 || !x3;
+  console.log(`      Verification: c1=${c1}, c2=${c2}, c3=${c3}, all=${c1 && c2 && c3}`);
+}
+
+// ==========================================================================
+// 5. SAT Problem from CNF String
+// ==========================================================================
+console.log('\n\n5. SAT from CNF String');
+console.log('   Parsing and solving CNF notation\n');
+
+const sat2 = new NPResonanceEncoder([]);
+sat2.fromCNF('(a OR b) AND (NOT a OR c) AND (b OR c)');
+
+console.log('   CNF: (a OR b) AND (NOT a OR c) AND (b OR c)');
+console.log(`   Variables: ${sat2.variables.join(', ')}`);
+console.log(`   Clauses: ${sat2.clauses.length}`);
+
+const solution2 = sat2.solve(50);
+console.log(`   Satisfiable: ${solution2.satisfiable}`);
+if (solution2.assignment) {
+  console.log(`   Assignment: ${JSON.stringify(solution2.assignment)}`);
+}
+
+// ==========================================================================
+// 6. Semantic Compression
+// ==========================================================================
+console.log('\n\n6. Semantic Compression via Attractor Convergence');
+console.log('   Map semantic content to hexagram codes\n');
+
+const compressor = new SemanticCompressor({ maxIterations: 30 });
+
+const texts = [
+  'The creative force initiates action',
+  'Creative energy drives innovation',
+  'Patience brings peace',
+  'Peaceful harmony prevails',
+  'Conflict arises from misunderstanding'
+];
+
+console.log('   Compressing texts:');
+const compressed = texts.map(text => {
+  const result = compressor.compress(text);
+  console.log(`      "${text.substring(0, 35)}..."`);
+  console.log(`         → Code: ${result.code} (${result.attractor})`);
+  return result;
+});
+
+// Find similar
+console.log('\n   Finding similar to "Creative power"');
+const similar = compressor.findSimilar('Creative power');
+console.log(`      Attractor: ${similar.attractor.number}. ${similar.attractor.name}`);
+console.log(`      Exact matches: ${similar.exact.length}`);
+console.log(`      Related: ${similar.related.length}`);
+
+// ==========================================================================
+// 7. Attractor Basin Analysis
+// ==========================================================================
+console.log('\n\n7. Attractor Basin Analysis');
+console.log('   Measuring convergence patterns\n');
+
+// Create random states and see which attractors they converge to
+const basinCounts = new Map();
+
+for (let i = 0; i < 20; i++) {
+  const state = PrimeState.uniform();
+  // Add some random perturbation
+  for (const p of state.primes) {
+    const phase = Math.random() * 2 * Math.PI;
+    state.set(p, state.get(p).mul({ re: Math.cos(phase), im: Math.sin(phase) }));
+  }
+  state.normalize();
+  
+  const result = oracle.query(state);
+  const key = result.attractor.number;
+  basinCounts.set(key, (basinCounts.get(key) || 0) + 1);
+}
+
+console.log('   Distribution of 20 random states across attractors:');
+const sorted = [...basinCounts.entries()].sort((a, b) => b[1] - a[1]);
+sorted.slice(0, 5).forEach(([num, count]) => {
+  const hex = HEXAGRAMS[num];
+  const name = hex ? hex.name : `Hexagram ${num}`;
+  console.log(`      ${num}. ${name}: ${count} states (${(count/20*100).toFixed(0)}%)`);
+});
+
+console.log('\n═══════════════════════════════════════════════════════════════');
+console.log('  ✅ book.pdf Chapters 10 & 11 Oracle Demo Complete!');
+console.log('═══════════════════════════════════════════════════════════════\n');

package/examples/physics/01-oscillator.js

@@ -0,0 +1,177 @@
+/**
+ * @example Coupled Oscillators
+ * @description Simulate coupled oscillator dynamics
+ * 
+ * TinyAleph's physics module includes oscillator simulations:
+ * - Kuramoto model for synchronization
+ * - Coupled phase dynamics
+ * - Emergence of collective behavior
+ */
+
+const { Oscillator } = require('../../physics/oscillator');
+const { KuramotoModel } = require('../../physics/kuramoto');
+
+console.log('TinyAleph Coupled Oscillators Example');
+console.log('=====================================\n');
+
+// ===========================================
+// SINGLE OSCILLATOR
+// ===========================================
+
+console.log('Single Oscillator:');
+console.log('-'.repeat(50) + '\n');
+
+var oscillator = new Oscillator(1.0, 0, 1.0);
+
+console.log('Initial state:');
+console.log('  Frequency: ' + oscillator.freq + ' Hz');
+console.log('  Phase: ' + oscillator.phase.toFixed(4) + ' rad');
+console.log('  Amplitude: ' + oscillator.amplitude);
+
+// Evolve over time
+console.log('\nTime evolution:');
+var times = [0, 0.25, 0.5, 0.75, 1.0];
+for (var i = 0; i < times.length; i++) {
+    var t = times[i];
+    var phase = oscillator.phase + 2 * Math.PI * oscillator.freq * t;
+    var value = oscillator.amplitude * Math.sin(phase);
+    console.log('  t=' + t.toFixed(2) + 's: phase=' + (phase % (2*Math.PI)).toFixed(3) + ', sin=' + value.toFixed(3));
+}
+
+// ===========================================
+// KURAMOTO MODEL
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('Kuramoto Model:');
+console.log('='.repeat(50) + '\n');
+
+console.log('Kuramoto model describes synchronization of coupled oscillators:');
+console.log('  dθᵢ/dt = ωᵢ + (K/N) Σⱼ sin(θⱼ - θᵢ)\n');
+
+var numOscillators = 5;
+var naturalFreqs = [];
+var phases = [];
+
+// Initialize with random frequencies and phases
+for (var i = 0; i < numOscillators; i++) {
+    naturalFreqs.push(0.8 + 0.4 * Math.random());
+    phases.push(2 * Math.PI * Math.random());
+}
+
+console.log('Initial state (5 oscillators):');
+for (var i = 0; i < numOscillators; i++) {
+    console.log('  Osc ' + i + ': ω=' + naturalFreqs[i].toFixed(3) + ', θ=' + phases[i].toFixed(3));
+}
+
+// Kuramoto evolution step
+function kuramotoStep(phases, freqs, coupling, dt) {
+    var N = phases.length;
+    var newPhases = [];
+    
+    for (var i = 0; i < N; i++) {
+        var interaction = 0;
+        for (var j = 0; j < N; j++) {
+            interaction += Math.sin(phases[j] - phases[i]);
+        }
+        interaction *= coupling / N;
+        
+        var dtheta = freqs[i] + interaction;
+        newPhases.push(phases[i] + dtheta * dt);
+    }
+    
+    return newPhases;
+}
+
+// Order parameter (measures synchronization)
+function orderParameter(phases) {
+    var sumCos = 0, sumSin = 0;
+    for (var i = 0; i < phases.length; i++) {
+        sumCos += Math.cos(phases[i]);
+        sumSin += Math.sin(phases[i]);
+    }
+    return Math.sqrt(sumCos*sumCos + sumSin*sumSin) / phases.length;
+}
+
+// Simulate with different coupling strengths
+console.log('\nSynchronization with coupling strength K:\n');
+
+var couplings = [0, 0.5, 1.0, 2.0, 5.0];
+
+for (var k = 0; k < couplings.length; k++) {
+    var K = couplings[k];
+    var currentPhases = phases.slice();
+    
+    // Evolve for 100 steps
+    for (var step = 0; step < 100; step++) {
+        currentPhases = kuramotoStep(currentPhases, naturalFreqs, K, 0.1);
+    }
+    
+    var r = orderParameter(currentPhases);
+    console.log('  K=' + K.toFixed(1) + ': order parameter r=' + r.toFixed(3) + ' (' + (r > 0.8 ? 'synchronized' : r > 0.5 ? 'partial' : 'desynchronized') + ')');
+}
+
+// ===========================================
+// SYNCHRONIZATION DYNAMICS
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('Synchronization Dynamics:');
+console.log('='.repeat(50) + '\n');
+
+console.log('Evolution of order parameter over time (K=2.0):\n');
+
+var K = 2.0;
+var evolvePhases = phases.slice();
+
+for (var step = 0; step <= 50; step += 10) {
+    var r = orderParameter(evolvePhases);
+    var bar = '';
+    for (var b = 0; b < Math.floor(r * 20); b++) bar += '█';
+    console.log('  Step ' + String(step).padStart(3) + ': r=' + r.toFixed(3) + ' |' + bar);
+    
+    // Evolve 10 steps
+    for (var s = 0; s < 10; s++) {
+        evolvePhases = kuramotoStep(evolvePhases, naturalFreqs, K, 0.1);
+    }
+}
+
+// ===========================================
+// PHASE DISTRIBUTION
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('Phase Distribution:');
+console.log('='.repeat(50) + '\n');
+
+// Show phase distribution at final state
+console.log('Final phase distribution (mod 2π):');
+var bins = new Array(8).fill(0);
+
+for (var i = 0; i < evolvePhases.length; i++) {
+    var normalizedPhase = ((evolvePhases[i] % (2*Math.PI)) + 2*Math.PI) % (2*Math.PI);
+    var bin = Math.floor(normalizedPhase / (2*Math.PI) * 8);
+    if (bin >= 8) bin = 7;
+    bins[bin]++;
+}
+
+for (var i = 0; i < 8; i++) {
+    var start = (i * 45).toString().padStart(3);
+    var end = ((i+1) * 45).toString().padStart(3);
+    var bar = '';
+    for (var b = 0; b < bins[i]; b++) bar += '█';
+    console.log('  ' + start + '°-' + end + '°: ' + bar);
+}
+
+// ===========================================
+// KEY TAKEAWAYS
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('KEY TAKEAWAYS:');
+console.log('1. Oscillators evolve with characteristic frequency');
+console.log('2. Kuramoto model couples oscillators via sine interaction');
+console.log('3. Order parameter r measures synchronization level');
+console.log('4. Above critical coupling, synchronization emerges');
+console.log('5. Phase distribution narrows as system synchronizes');
+console.log('6. Models fireflies, neurons, power grids, etc.');

package/examples/physics/02-lyapunov.js

@@ -0,0 +1,201 @@
+/**
+ * @example Lyapunov Exponents
+ * @description Analyze system stability using Lyapunov exponents
+ * 
+ * Lyapunov exponents measure sensitivity to initial conditions:
+ * - Positive: chaotic, trajectories diverge
+ * - Zero: marginally stable
+ * - Negative: stable, trajectories converge
+ */
+
+const Lyapunov = require('../../physics/lyapunov');
+
+console.log('TinyAleph Lyapunov Exponents Example');
+console.log('====================================\n');
+
+// ===========================================
+// LYAPUNOV BASICS
+// ===========================================
+
+console.log('Lyapunov Exponent Basics:');
+console.log('-'.repeat(50) + '\n');
+
+console.log('Lyapunov exponent λ measures exponential separation:');
+console.log('  |δx(t)| ≈ |δx(0)| e^(λt)');
+console.log('');
+console.log('  λ > 0: Chaotic (butterfly effect)');
+console.log('  λ = 0: Marginally stable');
+console.log('  λ < 0: Stable (perturbations decay)\n');
+
+// ===========================================
+// COMPUTING LYAPUNOV EXPONENTS
+// ===========================================
+
+console.log('='.repeat(50));
+console.log('Computing Lyapunov Exponents:');
+console.log('='.repeat(50) + '\n');
+
+// Simple 1D map: f(x) = rx(1-x) (logistic map)
+function logisticMap(x, r) {
+    return r * x * (1 - x);
+}
+
+function logisticMapDerivative(x, r) {
+    return r * (1 - 2 * x);
+}
+
+function computeLyapunov(r, x0, iterations, transient) {
+    transient = transient || 100;
+    
+    var x = x0;
+    
+    // Skip transient
+    for (var i = 0; i < transient; i++) {
+        x = logisticMap(x, r);
+    }
+    
+    // Compute Lyapunov exponent
+    var sumLog = 0;
+    for (var i = 0; i < iterations; i++) {
+        var derivative = Math.abs(logisticMapDerivative(x, r));
+        if (derivative > 0) {
+            sumLog += Math.log(derivative);
+        }
+        x = logisticMap(x, r);
+    }
+    
+    return sumLog / iterations;
+}
+
+// Test different r values for logistic map
+var rValues = [2.5, 3.0, 3.5, 3.8, 4.0];
+
+console.log('Logistic map: x_{n+1} = r * x_n * (1 - x_n)\n');
+console.log('r      λ          Behavior');
+console.log('-'.repeat(40));
+
+for (var i = 0; i < rValues.length; i++) {
+    var r = rValues[i];
+    var lambda = computeLyapunov(r, 0.5, 1000);
+    var behavior = lambda > 0 ? 'Chaotic' : lambda < -0.1 ? 'Stable fixed point' : 'Period doubling';
+    console.log(r.toFixed(1) + '    ' + lambda.toFixed(4).padStart(7) + '    ' + behavior);
+}
+
+// ===========================================
+// CHAOS IN LOGISTIC MAP
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('Chaos in Logistic Map:');
+console.log('='.repeat(50) + '\n');
+
+console.log('At r=4.0, the logistic map is fully chaotic.\n');
+
+// Show sensitive dependence
+var x1 = 0.5;
+var x2 = 0.5 + 1e-10;  // Tiny perturbation
+
+console.log('Sensitivity to initial conditions (r=4.0):');
+console.log('  x1(0) = 0.5');
+console.log('  x2(0) = 0.5 + 10^(-10)\n');
+
+console.log('Step    x1          x2          |x1-x2|');
+console.log('-'.repeat(50));
+
+for (var step = 0; step <= 50; step += 10) {
+    var diff = Math.abs(x1 - x2);
+    console.log(String(step).padStart(4) + '    ' + x1.toFixed(6).padStart(10) + '  ' + x2.toFixed(6).padStart(10) + '  ' + diff.toExponential(2));
+    
+    // Evolve 10 steps
+    for (var s = 0; s < 10; s++) {
+        x1 = logisticMap(x1, 4.0);
+        x2 = logisticMap(x2, 4.0);
+    }
+}
+
+console.log('\nNote: Tiny initial difference grows exponentially!');
+
+// ===========================================
+// STABILITY ANALYSIS
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('Stability Analysis:');
+console.log('='.repeat(50) + '\n');
+
+// Linear system stability
+function linearSystemLyapunov(A) {
+    // For 2x2 matrix, find eigenvalues
+    var a = A[0][0], b = A[0][1], c = A[1][0], d = A[1][1];
+    var trace = a + d;
+    var det = a * d - b * c;
+    
+    var discriminant = trace * trace - 4 * det;
+    
+    if (discriminant >= 0) {
+        var lambda1 = (trace + Math.sqrt(discriminant)) / 2;
+        var lambda2 = (trace - Math.sqrt(discriminant)) / 2;
+        return Math.max(Math.log(Math.abs(lambda1)), Math.log(Math.abs(lambda2)));
+    } else {
+        // Complex eigenvalues, magnitude is sqrt(det)
+        return Math.log(Math.sqrt(det));
+    }
+}
+
+var systems = [
+    { name: 'Stable node', matrix: [[0.5, 0], [0, 0.3]] },
+    { name: 'Saddle point', matrix: [[2, 0], [0, 0.25]] },
+    { name: 'Stable spiral', matrix: [[0.9, 0.4], [-0.4, 0.9]] },
+    { name: 'Unstable', matrix: [[1.1, 0], [0, 1.2]] }
+];
+
+console.log('Linear systems dx/dt = Ax:\n');
+console.log('System          λ_max      Stability');
+console.log('-'.repeat(45));
+
+for (var i = 0; i < systems.length; i++) {
+    var sys = systems[i];
+    var lambda = linearSystemLyapunov(sys.matrix);
+    var stability = lambda < 0 ? 'Stable' : lambda > 0 ? 'Unstable' : 'Marginal';
+    console.log(sys.name.padEnd(16) + lambda.toFixed(4).padStart(7) + '      ' + stability);
+}
+
+// ===========================================
+// PRACTICAL APPLICATIONS
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('Practical Applications:');
+console.log('='.repeat(50) + '\n');
+
+console.log('Lyapunov exponents are used in:');
+console.log('  - Weather prediction (limits of predictability)');
+console.log('  - Cardiac dynamics (detecting arrhythmias)');
+console.log('  - Financial markets (risk assessment)');
+console.log('  - Neural networks (edge of chaos)');
+console.log('  - Encryption (chaos-based cryptography)\n');
+
+// Predictability horizon
+console.log('Predictability horizon:');
+console.log('  For λ > 0, prediction error doubles every T = ln(2)/λ time units.\n');
+
+var lambda_weather = 1.0;  // Approximate for atmosphere
+var initial_error = 1e-6;
+var acceptable_error = 0.1;
+
+var predictability = Math.log(acceptable_error / initial_error) / lambda_weather;
+console.log('  Example: λ=' + lambda_weather + ', initial error=10^-6');
+console.log('  Time until error reaches 0.1: ' + predictability.toFixed(1) + ' time units');
+
+// ===========================================
+// KEY TAKEAWAYS
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('KEY TAKEAWAYS:');
+console.log('1. Lyapunov exponents measure chaos');
+console.log('2. λ > 0 indicates sensitive dependence');
+console.log('3. Computed from derivative along trajectory');
+console.log('4. Determines predictability horizon');
+console.log('5. Used in stability analysis of dynamical systems');
+console.log('6. TinyAleph uses λ to characterize semantic states');