@aleph-ai/tinyaleph 1.5.7 → 1.6.1

package/examples/physics/03-collapse.js

@@ -0,0 +1,183 @@
+/**
+ * @example State Collapse
+ * @description Explore quantum-inspired state collapse dynamics
+ * 
+ * TinyAleph models meaning as quantum-like state collapse:
+ * - Superposition of possible meanings
+ * - Context provides measurement
+ * - Collapse to definite interpretation
+ */
+
+const { SemanticBackend, Hypercomplex } = require('../../modular');
+const Collapse = require('../../physics/collapse');
+
+console.log('TinyAleph State Collapse Example');
+console.log('=================================\n');
+
+const backend = new SemanticBackend({ dimension: 16 });
+
+// ===========================================
+// COLLAPSE BASICS
+// ===========================================
+
+console.log('State Collapse Basics:');
+console.log('-'.repeat(50) + '\n');
+
+console.log('In TinyAleph, meaning collapse is analogous to quantum measurement:');
+console.log('  - Input text exists in superposition of interpretations');
+console.log('  - Context acts as measurement operator');
+console.log('  - Collapse produces definite meaning\n');
+
+// Create a superposition state
+var ambiguousWord = 'bank';  // Could mean financial or river
+var state = backend.textToOrderedState(ambiguousWord);
+
+console.log('Ambiguous word: "' + ambiguousWord + '"');
+console.log('State norm: ' + state.norm().toFixed(4));
+console.log('Components: [' + state.c.slice(0, 4).map(function(v) { return v.toFixed(3); }).join(', ') + '...]\n');
+
+// ===========================================
+// CONTEXT-DRIVEN COLLAPSE
+// ===========================================
+
+console.log('='.repeat(50));
+console.log('Context-Driven Collapse:');
+console.log('='.repeat(50) + '\n');
+
+// Different contexts for "bank"
+var contexts = [
+    { text: 'money deposit account financial', meaning: 'financial institution' },
+    { text: 'river water fish stream', meaning: 'river bank' },
+    { text: 'airplane turn angle aircraft', meaning: 'banking turn' }
+];
+
+function similarity(s1, s2) {
+    var dot = 0, m1 = 0, m2 = 0;
+    for (var i = 0; i < s1.c.length; i++) {
+        dot += s1.c[i] * s2.c[i];
+        m1 += s1.c[i] * s1.c[i];
+        m2 += s2.c[i] * s2.c[i];
+    }
+    return dot / (Math.sqrt(m1) * Math.sqrt(m2) || 1);
+}
+
+console.log('Context determines meaning collapse:\n');
+
+for (var i = 0; i < contexts.length; i++) {
+    var ctx = contexts[i];
+    var contextState = backend.textToOrderedState(ctx.text);
+    var combinedState = backend.textToOrderedState(ambiguousWord + ' ' + ctx.text);
+    
+    var sim = similarity(state, contextState);
+    
+    console.log('Context: "' + ctx.text + '"');
+    console.log('  Collapsed meaning: ' + ctx.meaning);
+    console.log('  Context-word similarity: ' + (sim * 100).toFixed(1) + '%\n');
+}
+
+// ===========================================
+// COLLAPSE DYNAMICS
+// ===========================================
+
+console.log('='.repeat(50));
+console.log('Collapse Dynamics:');
+console.log('='.repeat(50) + '\n');
+
+console.log('Collapse can be gradual or sudden depending on context strength.\n');
+
+// Simulate gradual collapse
+function interpolateStates(s1, s2, t) {
+    var result = Hypercomplex.zero(s1.c.length);
+    for (var i = 0; i < result.c.length; i++) {
+        result.c[i] = (1 - t) * s1.c[i] + t * s2.c[i];
+    }
+    return result.normalize();
+}
+
+var initialState = backend.textToOrderedState('unclear ambiguous vague');
+var finalState = backend.textToOrderedState('clear definite precise');
+
+console.log('Collapse trajectory from unclear to clear:\n');
+
+var ts = [0, 0.25, 0.5, 0.75, 1.0];
+for (var i = 0; i < ts.length; i++) {
+    var t = ts[i];
+    var interpolated = interpolateStates(initialState, finalState, t);
+    console.log('  t=' + t.toFixed(2) + ': norm=' + interpolated.norm().toFixed(4) + 
+                ', similarity to final=' + (similarity(interpolated, finalState) * 100).toFixed(1) + '%');
+}
+
+// ===========================================
+// ENTROPY AND COLLAPSE
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('Entropy and Collapse:');
+console.log('='.repeat(50) + '\n');
+
+console.log('Entropy measures uncertainty in the state:');
+console.log('  - High entropy: many possible meanings');
+console.log('  - Low entropy: definite meaning');
+console.log('  - Collapse reduces entropy\n');
+
+function computeEntropy(state) {
+    // Treat squared components as probabilities
+    var probs = [];
+    var sum = 0;
+    
+    for (var i = 0; i < state.c.length; i++) {
+        var p = state.c[i] * state.c[i];
+        probs.push(p);
+        sum += p;
+    }
+    
+    // Normalize and compute entropy
+    var entropy = 0;
+    for (var i = 0; i < probs.length; i++) {
+        var p = probs[i] / sum;
+        if (p > 0) {
+            entropy -= p * Math.log2(p);
+        }
+    }
+    
+    return entropy;
+}
+
+var vague = backend.textToOrderedState('something somewhere somehow');
+var specific = backend.textToOrderedState('the cat sat on the mat');
+
+console.log('Entropy comparison:');
+console.log('  "something somewhere somehow": H=' + computeEntropy(vague).toFixed(3) + ' bits');
+console.log('  "the cat sat on the mat": H=' + computeEntropy(specific).toFixed(3) + ' bits');
+
+// ===========================================
+// COLLAPSE REVERSIBILITY
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('Collapse (Ir)reversibility:');
+console.log('='.repeat(50) + '\n');
+
+console.log('Unlike quantum measurement, semantic collapse can be partially reversed:');
+console.log('  - New context can shift interpretation');
+console.log('  - But original superposition is lost');
+console.log('  - "Garden path" sentences demonstrate this\n');
+
+var gardenPath = 'The horse raced past the barn fell';
+console.log('Garden path: "' + gardenPath + '"');
+console.log('Initial parse: The horse raced... (active)');
+console.log('Reanalysis: The horse [that was] raced past the barn fell (passive)');
+console.log('Context forces re-collapse of syntactic interpretation.');
+
+// ===========================================
+// KEY TAKEAWAYS
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('KEY TAKEAWAYS:');
+console.log('1. Meaning exists in superposition before context');
+console.log('2. Context acts as measurement operator');
+console.log('3. Collapse produces definite interpretation');
+console.log('4. Entropy measures uncertainty in meaning');
+console.log('5. Collapse can be gradual or sudden');
+console.log('6. Reanalysis allows partial reversal');

package/examples/physics/04-kuramoto.js

@@ -0,0 +1,212 @@
+/**
+ * @example Kuramoto Synchronization
+ * @description Deep dive into Kuramoto model dynamics
+ * 
+ * The Kuramoto model describes synchronization of coupled oscillators:
+ * - Phase dynamics with coupling
+ * - Critical coupling threshold
+ * - Order parameter emergence
+ */
+
+console.log('TinyAleph Kuramoto Synchronization Example');
+console.log('==========================================\n');
+
+// ===========================================
+// KURAMOTO MODEL
+// ===========================================
+
+console.log('Kuramoto Model:');
+console.log('-'.repeat(50) + '\n');
+
+console.log('Model equation: dθᵢ/dt = ωᵢ + (K/N) Σⱼ sin(θⱼ - θᵢ)');
+console.log('');
+console.log('Parameters:');
+console.log('  θᵢ: Phase of oscillator i');
+console.log('  ωᵢ: Natural frequency of oscillator i');
+console.log('  K: Coupling strength');
+console.log('  N: Number of oscillators\n');
+
+// ===========================================
+// SIMULATION SETUP
+// ===========================================
+
+console.log('='.repeat(50));
+console.log('Simulation Setup:');
+console.log('='.repeat(50) + '\n');
+
+function createOscillatorSystem(N, freqSpread) {
+    var system = {
+        N: N,
+        phases: [],
+        frequencies: [],
+        K: 0
+    };
+    
+    // Initialize with random phases and Lorentzian frequency distribution
+    for (var i = 0; i < N; i++) {
+        system.phases.push(2 * Math.PI * Math.random());
+        // Lorentzian distribution centered at 1.0
+        var u = Math.random();
+        system.frequencies.push(1.0 + freqSpread * Math.tan(Math.PI * (u - 0.5)));
+    }
+    
+    return system;
+}
+
+var system = createOscillatorSystem(50, 0.5);
+console.log('Created system with ' + system.N + ' oscillators');
+console.log('Frequency range: [' + 
+    Math.min.apply(null, system.frequencies).toFixed(2) + ', ' + 
+    Math.max.apply(null, system.frequencies).toFixed(2) + ']\n');
+
+// ===========================================
+// EVOLUTION AND ORDER PARAMETER
+// ===========================================
+
+console.log('='.repeat(50));
+console.log('Evolution and Order Parameter:');
+console.log('='.repeat(50) + '\n');
+
+function evolveKuramoto(system, dt) {
+    var N = system.N;
+    var newPhases = [];
+    
+    for (var i = 0; i < N; i++) {
+        var coupling = 0;
+        for (var j = 0; j < N; j++) {
+            coupling += Math.sin(system.phases[j] - system.phases[i]);
+        }
+        coupling *= system.K / N;
+        
+        var dphase = system.frequencies[i] + coupling;
+        newPhases.push(system.phases[i] + dphase * dt);
+    }
+    
+    system.phases = newPhases;
+}
+
+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]);
+    }
+    var N = phases.length;
+    var r = Math.sqrt(sumCos*sumCos + sumSin*sumSin) / N;
+    var psi = Math.atan2(sumSin, sumCos);
+    return { r: r, psi: psi };
+}
+
+console.log('Order parameter r ∈ [0, 1]:');
+console.log('  r = 0: Incoherent (random phases)');
+console.log('  r = 1: Fully synchronized (identical phases)\n');
+
+// Test different coupling strengths
+console.log('Coupling  Initial r  Final r   Status');
+console.log('-'.repeat(50));
+
+var couplings = [0, 1, 2, 3, 4, 5];
+
+for (var c = 0; c < couplings.length; c++) {
+    var K = couplings[c];
+    
+    // Reset system
+    var testSystem = createOscillatorSystem(50, 0.5);
+    testSystem.K = K;
+    
+    var initialR = orderParameter(testSystem.phases).r;
+    
+    // Evolve for 1000 steps
+    for (var step = 0; step < 1000; step++) {
+        evolveKuramoto(testSystem, 0.05);
+    }
+    
+    var finalR = orderParameter(testSystem.phases).r;
+    var status = finalR > 0.8 ? 'Synchronized' : finalR > 0.3 ? 'Partial' : 'Incoherent';
+    
+    console.log(K.toFixed(1).padStart(5) + '       ' + 
+                initialR.toFixed(3) + '      ' + 
+                finalR.toFixed(3) + '     ' + status);
+}
+
+// ===========================================
+// CRITICAL COUPLING
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('Critical Coupling:');
+console.log('='.repeat(50) + '\n');
+
+console.log('Critical coupling Kc marks the synchronization transition:');
+console.log('  K < Kc: Incoherent state');
+console.log('  K > Kc: Partial synchronization');
+console.log('  K >> Kc: Full synchronization\n');
+
+// Estimate critical coupling
+console.log('Estimating critical coupling...\n');
+
+var Kc_estimate = 2.5;  // Approximate for our parameters
+console.log('For Lorentzian frequency distribution:');
+console.log('  Kc = 2γ (where γ is width parameter)');
+console.log('  Estimated Kc ≈ ' + Kc_estimate.toFixed(1));
+
+// ===========================================
+// PHASE TRANSITION
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('Phase Transition:');
+console.log('='.repeat(50) + '\n');
+
+console.log('Order parameter r vs coupling K:\n');
+
+var Krange = [];
+var rValues = [];
+
+for (var K = 0; K <= 6; K += 0.5) {
+    var testSystem = createOscillatorSystem(50, 0.5);
+    testSystem.K = K;
+    
+    // Evolve to steady state
+    for (var step = 0; step < 2000; step++) {
+        evolveKuramoto(testSystem, 0.02);
+    }
+    
+    var r = orderParameter(testSystem.phases).r;
+    Krange.push(K);
+    rValues.push(r);
+    
+    // ASCII plot
+    var bar = '';
+    for (var b = 0; b < Math.floor(r * 30); b++) bar += '█';
+    console.log('K=' + K.toFixed(1).padStart(3) + ': |' + bar.padEnd(30) + '| r=' + r.toFixed(2));
+}
+
+// ===========================================
+// APPLICATIONS
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('Applications:');
+console.log('='.repeat(50) + '\n');
+
+console.log('Kuramoto model applies to:');
+console.log('  - Firefly synchronization');
+console.log('  - Circadian rhythms');
+console.log('  - Power grid stability');
+console.log('  - Neural oscillations');
+console.log('  - Coupled lasers');
+console.log('  - Semantic concept synchronization\n');
+
+// ===========================================
+// KEY TAKEAWAYS
+// ===========================================
+
+console.log('='.repeat(50));
+console.log('KEY TAKEAWAYS:');
+console.log('1. Kuramoto model describes coupled oscillator sync');
+console.log('2. Order parameter r measures collective coherence');
+console.log('3. Critical coupling Kc triggers phase transition');
+console.log('4. Above Kc, oscillators spontaneously synchronize');
+console.log('5. Models many natural synchronization phenomena');
+console.log('6. TinyAleph uses for semantic field coherence');

package/examples/physics/05-entropy.js

@@ -0,0 +1,226 @@
+/**
+ * @example Entropy Analysis
+ * @description Analyze information entropy in semantic states
+ * 
+ * Entropy measures uncertainty and information content:
+ * - Shannon entropy for discrete distributions
+ * - Differential entropy for continuous
+ * - Connects to thermodynamics and information theory
+ */
+
+const { SemanticBackend, Hypercomplex } = require('../../modular');
+const Entropy = require('../../physics/entropy');
+
+console.log('TinyAleph Entropy Analysis Example');
+console.log('===================================\n');
+
+const backend = new SemanticBackend({ dimension: 16 });
+
+// ===========================================
+// ENTROPY BASICS
+// ===========================================
+
+console.log('Entropy Basics:');
+console.log('-'.repeat(50) + '\n');
+
+console.log('Shannon entropy: H(X) = -Σ p(x) log₂ p(x)');
+console.log('');
+console.log('Properties:');
+console.log('  - H ≥ 0 (always non-negative)');
+console.log('  - H = 0 for certainty (single outcome)');
+console.log('  - H = log₂(n) for uniform distribution over n outcomes');
+console.log('');
+
+// ===========================================
+// COMPUTING ENTROPY
+// ===========================================
+
+console.log('='.repeat(50));
+console.log('Computing Entropy:');
+console.log('='.repeat(50) + '\n');
+
+function shannonEntropy(probs) {
+    var H = 0;
+    for (var i = 0; i < probs.length; i++) {
+        if (probs[i] > 0) {
+            H -= probs[i] * Math.log2(probs[i]);
+        }
+    }
+    return H;
+}
+
+// Examples
+var certain = [1, 0, 0, 0];
+var uniform = [0.25, 0.25, 0.25, 0.25];
+var biased = [0.7, 0.2, 0.07, 0.03];
+var binary = [0.5, 0.5];
+
+console.log('Distribution            Entropy');
+console.log('-'.repeat(40));
+console.log('Certain [1,0,0,0]:      ' + shannonEntropy(certain).toFixed(3) + ' bits');
+console.log('Uniform [.25,.25,.25,.25]: ' + shannonEntropy(uniform).toFixed(3) + ' bits');
+console.log('Biased [.7,.2,.07,.03]: ' + shannonEntropy(biased).toFixed(3) + ' bits');
+console.log('Binary [.5,.5]:         ' + shannonEntropy(binary).toFixed(3) + ' bits');
+
+// ===========================================
+// SEMANTIC STATE ENTROPY
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('Semantic State Entropy:');
+console.log('='.repeat(50) + '\n');
+
+function stateEntropy(state) {
+    // Treat squared normalized components as probabilities
+    var probs = [];
+    var sum = 0;
+    
+    for (var i = 0; i < state.c.length; i++) {
+        var p = state.c[i] * state.c[i];
+        probs.push(p);
+        sum += p;
+    }
+    
+    // Normalize
+    for (var i = 0; i < probs.length; i++) {
+        probs[i] /= sum;
+    }
+    
+    return shannonEntropy(probs);
+}
+
+var texts = [
+    'a',
+    'the cat',
+    'the quick brown fox jumps over the lazy dog',
+    'asjdkfh qwerty zxcvbn random nonsense words gibberish'
+];
+
+console.log('Text entropy (16-dimensional state):\n');
+
+for (var i = 0; i < texts.length; i++) {
+    var text = texts[i];
+    var state = backend.textToOrderedState(text);
+    var H = stateEntropy(state);
+    console.log('  "' + text.substring(0, 35) + (text.length > 35 ? '...' : '') + '"');
+    console.log('    Entropy: ' + H.toFixed(3) + ' bits\n');
+}
+
+// ===========================================
+// ENTROPY AND MEANING
+// ===========================================
+
+console.log('='.repeat(50));
+console.log('Entropy and Meaning:');
+console.log('='.repeat(50) + '\n');
+
+console.log('Low entropy states:');
+console.log('  - Concentrated, specific meaning');
+console.log('  - Few active dimensions');
+console.log('  - Clear, unambiguous\n');
+
+console.log('High entropy states:');
+console.log('  - Distributed, general meaning');
+console.log('  - Many active dimensions');
+console.log('  - Vague, ambiguous\n');
+
+// Compare specific vs general texts
+var specific = backend.textToOrderedState('hydrogen atom electron orbital');
+var general = backend.textToOrderedState('thing stuff entity concept');
+
+console.log('Comparison:');
+console.log('  "hydrogen atom electron orbital": H=' + stateEntropy(specific).toFixed(3) + ' bits');
+console.log('  "thing stuff entity concept": H=' + stateEntropy(general).toFixed(3) + ' bits');
+
+// ===========================================
+// CONDITIONAL ENTROPY
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('Conditional Entropy:');
+console.log('='.repeat(50) + '\n');
+
+console.log('H(Y|X): Uncertainty in Y given knowledge of X');
+console.log('H(Y|X) ≤ H(Y): Conditioning reduces entropy\n');
+
+function conditionalEntropy(stateY, stateX) {
+    // Simplified: measure how much Y's entropy decreases given X
+    var Hy = stateEntropy(stateY);
+    
+    // Combine states
+    var combined = Hypercomplex.zero(stateY.c.length);
+    for (var i = 0; i < combined.c.length; i++) {
+        combined.c[i] = (stateY.c[i] + stateX.c[i]) / 2;
+    }
+    var Hxy = stateEntropy(combined.normalize());
+    
+    // H(Y|X) ≈ H(X,Y) - H(X)
+    return Math.max(0, Hxy);
+}
+
+var y = backend.textToOrderedState('animal');
+var x1 = backend.textToOrderedState('cat');  // Specific context
+var x2 = backend.textToOrderedState('thing');  // Vague context
+
+console.log('Uncertainty about "animal" given context:\n');
+console.log('  H(animal): ' + stateEntropy(y).toFixed(3) + ' bits');
+console.log('  H(animal|cat): ' + conditionalEntropy(y, x1).toFixed(3) + ' bits');
+console.log('  H(animal|thing): ' + conditionalEntropy(y, x2).toFixed(3) + ' bits');
+
+// ===========================================
+// RELATIVE ENTROPY (KL DIVERGENCE)
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('Relative Entropy (KL Divergence):');
+console.log('='.repeat(50) + '\n');
+
+console.log('D_KL(P||Q) = Σ P(x) log(P(x)/Q(x))');
+console.log('Measures "distance" between distributions.\n');
+
+function klDivergence(state1, state2) {
+    var probs1 = [], probs2 = [];
+    var sum1 = 0, sum2 = 0;
+    
+    for (var i = 0; i < state1.c.length; i++) {
+        var p1 = state1.c[i] * state1.c[i];
+        var p2 = state2.c[i] * state2.c[i];
+        probs1.push(p1);
+        probs2.push(p2);
+        sum1 += p1;
+        sum2 += p2;
+    }
+    
+    var kl = 0;
+    for (var i = 0; i < probs1.length; i++) {
+        var p = probs1[i] / sum1;
+        var q = probs2[i] / sum2 + 1e-10;  // Avoid log(0)
+        if (p > 0) {
+            kl += p * Math.log2(p / q);
+        }
+    }
+    
+    return kl;
+}
+
+var cat = backend.textToOrderedState('cat');
+var dog = backend.textToOrderedState('dog');
+var car = backend.textToOrderedState('car');
+
+console.log('KL divergence between concepts:\n');
+console.log('  D(cat||dog) = ' + klDivergence(cat, dog).toFixed(3) + ' bits');
+console.log('  D(cat||car) = ' + klDivergence(cat, car).toFixed(3) + ' bits');
+console.log('  D(dog||car) = ' + klDivergence(dog, car).toFixed(3) + ' bits');
+
+// ===========================================
+// KEY TAKEAWAYS
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('KEY TAKEAWAYS:');
+console.log('1. Entropy measures uncertainty in a state');
+console.log('2. Low entropy = specific, high entropy = vague');
+console.log('3. Context reduces conditional entropy');
+console.log('4. KL divergence measures state divergence');
+console.log('5. Entropy connects information and thermodynamics');
+console.log('6. TinyAleph uses entropy for semantic analysis');