@aleph-ai/tinyaleph 1.5.6 → 1.6.0

package/examples/math/01-quaternions.js

@@ -0,0 +1,237 @@
+/**
+ * @example Quaternions
+ * @description Explore quaternion algebra using hypercomplex numbers
+ * 
+ * Quaternions are 4-dimensional hypercomplex numbers:
+ * - q = a + bi + cj + dk
+ * - Used for 3D rotations without gimbal lock
+ * - Non-commutative multiplication
+ */
+
+const { Hypercomplex } = require('../../modular');
+
+console.log('TinyAleph Quaternion Example');
+console.log('============================\n');
+
+// ===========================================
+// QUATERNION BASICS
+// ===========================================
+
+console.log('Quaternion Basics:');
+console.log('-'.repeat(50) + '\n');
+
+console.log('Quaternions: q = a + bi + cj + dk');
+console.log('Where: i² = j² = k² = ijk = -1\n');
+
+// Create quaternions using Hypercomplex with dimension 4
+function createQuaternion(a, b, c, d) {
+    var q = Hypercomplex.zero(4);
+    q.c[0] = a;  // Real part
+    q.c[1] = b;  // i component
+    q.c[2] = c;  // j component
+    q.c[3] = d;  // k component
+    return q;
+}
+
+function quaternionToString(q) {
+    var parts = [];
+    if (q.c[0] !== 0) parts.push(q.c[0].toFixed(3));
+    if (q.c[1] !== 0) parts.push(q.c[1].toFixed(3) + 'i');
+    if (q.c[2] !== 0) parts.push(q.c[2].toFixed(3) + 'j');
+    if (q.c[3] !== 0) parts.push(q.c[3].toFixed(3) + 'k');
+    return parts.length > 0 ? parts.join(' + ').replace(/\+ -/g, '- ') : '0';
+}
+
+var q1 = createQuaternion(1, 2, 3, 4);
+var q2 = createQuaternion(2, -1, 1, 3);
+
+console.log('q1 = ' + quaternionToString(q1));
+console.log('q2 = ' + quaternionToString(q2));
+
+// ===========================================
+// QUATERNION OPERATIONS
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('Quaternion Operations:');
+console.log('='.repeat(50) + '\n');
+
+// Addition
+function quaternionAdd(q1, q2) {
+    var result = Hypercomplex.zero(4);
+    for (var i = 0; i < 4; i++) {
+        result.c[i] = q1.c[i] + q2.c[i];
+    }
+    return result;
+}
+
+var sum = quaternionAdd(q1, q2);
+console.log('Addition:');
+console.log('  q1 + q2 = ' + quaternionToString(sum));
+
+// Quaternion multiplication (Hamilton product)
+function quaternionMul(q1, q2) {
+    var a1 = q1.c[0], b1 = q1.c[1], c1 = q1.c[2], d1 = q1.c[3];
+    var a2 = q2.c[0], b2 = q2.c[1], c2 = q2.c[2], d2 = q2.c[3];
+    
+    var result = Hypercomplex.zero(4);
+    result.c[0] = a1*a2 - b1*b2 - c1*c2 - d1*d2;
+    result.c[1] = a1*b2 + b1*a2 + c1*d2 - d1*c2;
+    result.c[2] = a1*c2 - b1*d2 + c1*a2 + d1*b2;
+    result.c[3] = a1*d2 + b1*c2 - c1*b2 + d1*a2;
+    
+    return result;
+}
+
+var prod = quaternionMul(q1, q2);
+console.log('\nMultiplication:');
+console.log('  q1 * q2 = ' + quaternionToString(prod));
+
+// Non-commutativity
+var prod2 = quaternionMul(q2, q1);
+console.log('  q2 * q1 = ' + quaternionToString(prod2));
+console.log('  Non-commutative: q1*q2 ≠ q2*q1');
+
+// Conjugate
+function quaternionConjugate(q) {
+    var result = Hypercomplex.zero(4);
+    result.c[0] = q.c[0];
+    result.c[1] = -q.c[1];
+    result.c[2] = -q.c[2];
+    result.c[3] = -q.c[3];
+    return result;
+}
+
+var conj = quaternionConjugate(q1);
+console.log('\nConjugate:');
+console.log('  q1* = ' + quaternionToString(conj));
+
+// Norm
+function quaternionNorm(q) {
+    return Math.sqrt(q.c[0]*q.c[0] + q.c[1]*q.c[1] + q.c[2]*q.c[2] + q.c[3]*q.c[3]);
+}
+
+console.log('\nNorm:');
+console.log('  |q1| = ' + quaternionNorm(q1).toFixed(4));
+
+// ===========================================
+// UNIT QUATERNIONS AND ROTATIONS
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('Unit Quaternions and 3D Rotations:');
+console.log('='.repeat(50) + '\n');
+
+console.log('Unit quaternions (|q| = 1) represent 3D rotations.');
+console.log('Rotation by angle θ around axis (x, y, z):');
+console.log('  q = cos(θ/2) + sin(θ/2)(xi + yj + zk)\n');
+
+function rotationQuaternion(axis, angle) {
+    // Normalize axis
+    var mag = Math.sqrt(axis[0]*axis[0] + axis[1]*axis[1] + axis[2]*axis[2]);
+    var x = axis[0] / mag;
+    var y = axis[1] / mag;
+    var z = axis[2] / mag;
+    
+    var halfAngle = angle / 2;
+    var s = Math.sin(halfAngle);
+    
+    return createQuaternion(
+        Math.cos(halfAngle),
+        x * s,
+        y * s,
+        z * s
+    );
+}
+
+// 90 degree rotation around Z axis
+var rotation = rotationQuaternion([0, 0, 1], Math.PI / 2);
+console.log('90° rotation around Z axis:');
+console.log('  q = ' + quaternionToString(rotation));
+console.log('  |q| = ' + quaternionNorm(rotation).toFixed(4) + ' (unit quaternion)');
+
+// Rotate a vector
+function rotateVector(v, q) {
+    // v' = q * v * q*
+    var vQuat = createQuaternion(0, v[0], v[1], v[2]);
+    var qConj = quaternionConjugate(q);
+    
+    var result = quaternionMul(quaternionMul(q, vQuat), qConj);
+    return [result.c[1], result.c[2], result.c[3]];
+}
+
+var original = [1, 0, 0];
+var rotated = rotateVector(original, rotation);
+
+console.log('\nRotating vector [1, 0, 0]:');
+console.log('  Original: [' + original.join(', ') + ']');
+console.log('  Rotated:  [' + rotated.map(function(v) { return v.toFixed(4); }).join(', ') + ']');
+console.log('  Expected: [0, 1, 0] (90° around Z)');
+
+// ===========================================
+// QUATERNION INTERPOLATION (SLERP)
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('Quaternion Interpolation (SLERP):');
+console.log('='.repeat(50) + '\n');
+
+console.log('SLERP smoothly interpolates between rotations.\n');
+
+function slerp(q1, q2, t) {
+    // Compute dot product
+    var dot = q1.c[0]*q2.c[0] + q1.c[1]*q2.c[1] + q1.c[2]*q2.c[2] + q1.c[3]*q2.c[3];
+    
+    // If negative dot, negate one quaternion
+    if (dot < 0) {
+        q2 = createQuaternion(-q2.c[0], -q2.c[1], -q2.c[2], -q2.c[3]);
+        dot = -dot;
+    }
+    
+    // Clamp
+    dot = Math.min(dot, 1);
+    
+    var theta = Math.acos(dot);
+    var sinTheta = Math.sin(theta);
+    
+    var result = Hypercomplex.zero(4);
+    
+    if (sinTheta < 0.001) {
+        // Linear interpolation for small angles
+        for (var i = 0; i < 4; i++) {
+            result.c[i] = (1 - t) * q1.c[i] + t * q2.c[i];
+        }
+    } else {
+        var a = Math.sin((1 - t) * theta) / sinTheta;
+        var b = Math.sin(t * theta) / sinTheta;
+        for (var i = 0; i < 4; i++) {
+            result.c[i] = a * q1.c[i] + b * q2.c[i];
+        }
+    }
+    
+    return result;
+}
+
+var q_start = rotationQuaternion([0, 0, 1], 0);
+var q_end = rotationQuaternion([0, 0, 1], Math.PI);
+
+console.log('Interpolating 0° to 180° rotation around Z:');
+var ts = [0, 0.25, 0.5, 0.75, 1.0];
+for (var i = 0; i < ts.length; i++) {
+    var t = ts[i];
+    var interp = slerp(q_start, q_end, t);
+    console.log('  t=' + t.toFixed(2) + ': ' + quaternionToString(interp));
+}
+
+// ===========================================
+// KEY TAKEAWAYS
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('KEY TAKEAWAYS:');
+console.log('1. Quaternions are 4D hypercomplex numbers');
+console.log('2. Multiplication is non-commutative');
+console.log('3. Unit quaternions represent 3D rotations');
+console.log('4. No gimbal lock unlike Euler angles');
+console.log('5. SLERP provides smooth rotation interpolation');
+console.log('6. Used in 3D graphics, robotics, aerospace');

package/examples/math/02-octonions.js

@@ -0,0 +1,192 @@
+/**
+ * @example Octonions
+ * @description Explore 8-dimensional hypercomplex algebra
+ * 
+ * Octonions are 8-dimensional hypercomplex numbers:
+ * - Extension of quaternions
+ * - Non-associative multiplication
+ * - Related to exceptional Lie groups
+ */
+
+const { Hypercomplex } = require('../../modular');
+
+console.log('TinyAleph Octonion Example');
+console.log('==========================\n');
+
+// ===========================================
+// OCTONION BASICS
+// ===========================================
+
+console.log('Octonion Basics:');
+console.log('-'.repeat(50) + '\n');
+
+console.log('Octonions: o = a₀ + a₁e₁ + a₂e₂ + a₃e₃ + a₄e₄ + a₅e₅ + a₆e₆ + a₇e₇');
+console.log('8-dimensional hypercomplex numbers with 7 imaginary units.\n');
+
+console.log('Hierarchy of hypercomplex numbers:');
+console.log('  Real (1D) → Complex (2D) → Quaternions (4D) → Octonions (8D)\n');
+
+// Create octonion using Hypercomplex with dimension 8
+function createOctonion(components) {
+    var o = Hypercomplex.zero(8);
+    for (var i = 0; i < Math.min(components.length, 8); i++) {
+        o.c[i] = components[i];
+    }
+    return o;
+}
+
+function octonionToString(o) {
+    var parts = [];
+    var labels = ['', 'e₁', 'e₂', 'e₃', 'e₄', 'e₅', 'e₆', 'e₇'];
+    
+    for (var i = 0; i < 8; i++) {
+        if (Math.abs(o.c[i]) > 0.0001) {
+            if (i === 0) {
+                parts.push(o.c[i].toFixed(2));
+            } else {
+                parts.push(o.c[i].toFixed(2) + labels[i]);
+            }
+        }
+    }
+    return parts.length > 0 ? parts.join(' + ').replace(/\+ -/g, '- ') : '0';
+}
+
+var o1 = createOctonion([1, 2, 0, 0, 1, 0, 0, 0]);
+var o2 = createOctonion([0, 1, 1, 0, 0, 1, 0, 1]);
+
+console.log('o1 = ' + octonionToString(o1));
+console.log('o2 = ' + octonionToString(o2));
+
+// ===========================================
+// OCTONION OPERATIONS
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('Octonion Operations:');
+console.log('='.repeat(50) + '\n');
+
+// Addition
+function octonionAdd(o1, o2) {
+    var result = Hypercomplex.zero(8);
+    for (var i = 0; i < 8; i++) {
+        result.c[i] = o1.c[i] + o2.c[i];
+    }
+    return result;
+}
+
+var sum = octonionAdd(o1, o2);
+console.log('Addition:');
+console.log('  o1 + o2 = ' + octonionToString(sum));
+
+// Conjugate
+function octonionConjugate(o) {
+    var result = Hypercomplex.zero(8);
+    result.c[0] = o.c[0];
+    for (var i = 1; i < 8; i++) {
+        result.c[i] = -o.c[i];
+    }
+    return result;
+}
+
+var conj = octonionConjugate(o1);
+console.log('\nConjugate:');
+console.log('  o1* = ' + octonionToString(conj));
+
+// Norm
+function octonionNorm(o) {
+    var sum = 0;
+    for (var i = 0; i < 8; i++) {
+        sum += o.c[i] * o.c[i];
+    }
+    return Math.sqrt(sum);
+}
+
+console.log('\nNorm:');
+console.log('  |o1| = ' + octonionNorm(o1).toFixed(4));
+console.log('  |o2| = ' + octonionNorm(o2).toFixed(4));
+
+// ===========================================
+// OCTONION MULTIPLICATION
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('Octonion Multiplication:');
+console.log('='.repeat(50) + '\n');
+
+console.log('Octonion multiplication is:');
+console.log('  - Non-commutative: o1 * o2 ≠ o2 * o1');
+console.log('  - Non-associative: (o1 * o2) * o3 ≠ o1 * (o2 * o3)');
+console.log('  - Alternative: o * (o * x) = o² * x\n');
+
+// Fano plane multiplication table for octonions
+// This encodes the multiplication rules for e1...e7
+var fanoMul = [
+    [1, 2, 3, 4, 5, 6, 7],  // e1 * en
+    [2, -1, 4, -3, 6, -5, -8],
+    [3, -4, -1, 2, 7, 8, -5],
+    [4, 3, -2, -1, 8, -7, 6],
+    [5, -6, -7, -8, -1, 2, 3],
+    [6, 5, -8, 7, -2, -1, -4],
+    [7, 8, 5, -6, -3, 4, -1]
+];
+
+console.log('Octonion multiplication uses the Fano plane structure.');
+console.log('This defines the relationships between the 7 imaginary units.\n');
+
+// Simplified multiplication (demonstrating non-associativity)
+var e1 = createOctonion([0, 1, 0, 0, 0, 0, 0, 0]);
+var e2 = createOctonion([0, 0, 1, 0, 0, 0, 0, 0]);
+var e4 = createOctonion([0, 0, 0, 0, 1, 0, 0, 0]);
+
+console.log('Basis elements:');
+console.log('  e1 = ' + octonionToString(e1));
+console.log('  e2 = ' + octonionToString(e2));
+console.log('  e4 = ' + octonionToString(e4));
+
+// ===========================================
+// NORMED DIVISION ALGEBRAS
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('Normed Division Algebras:');
+console.log('='.repeat(50) + '\n');
+
+console.log('There are only 4 normed division algebras:');
+console.log('  1. Real numbers (R) - 1D');
+console.log('  2. Complex numbers (C) - 2D');
+console.log('  3. Quaternions (H) - 4D');
+console.log('  4. Octonions (O) - 8D\n');
+
+console.log('As dimensions increase, we lose properties:');
+console.log('  R: commutative, associative, ordered');
+console.log('  C: commutative, associative, not ordered');
+console.log('  H: not commutative, associative');
+console.log('  O: not commutative, not associative');
+
+// ===========================================
+// APPLICATIONS
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('Octonion Applications:');
+console.log('='.repeat(50) + '\n');
+
+console.log('Despite being exotic, octonions appear in:');
+console.log('  - String theory and M-theory');
+console.log('  - Exceptional Lie groups (G2, F4, E6, E7, E8)');
+console.log('  - Bott periodicity theorem');
+console.log('  - Supersymmetry');
+console.log('  - Some approaches to quantum gravity\n');
+
+// ===========================================
+// KEY TAKEAWAYS
+// ===========================================
+
+console.log('='.repeat(50));
+console.log('KEY TAKEAWAYS:');
+console.log('1. Octonions are 8D hypercomplex numbers');
+console.log('2. Multiplication is non-associative');
+console.log('3. Last of the normed division algebras');
+console.log('4. Related to exceptional mathematical structures');
+console.log('5. Applications in theoretical physics');
+console.log('6. TinyAleph dimension=8 represents octonions');

package/examples/math/03-prime-factorization.js

@@ -0,0 +1,215 @@
+/**
+ * @example Prime Factorization
+ * @description Explore prime numbers and factorization
+ * 
+ * Prime numbers are fundamental to TinyAleph:
+ * - Words map to primes
+ * - Products encode ordered sequences
+ * - Unique factorization enables decoding
+ */
+
+const { SemanticBackend } = require('../../modular');
+
+console.log('TinyAleph Prime Factorization Example');
+console.log('=====================================\n');
+
+const backend = new SemanticBackend({ dimension: 16 });
+
+// ===========================================
+// PRIME BASICS
+// ===========================================
+
+console.log('Prime Number Basics:');
+console.log('-'.repeat(50) + '\n');
+
+console.log('A prime number is divisible only by 1 and itself.');
+console.log('Fundamental Theorem: Every integer > 1 has unique prime factorization.\n');
+
+// Generate primes using sieve
+function sieveOfEratosthenes(limit) {
+    var sieve = new Array(limit + 1).fill(true);
+    sieve[0] = sieve[1] = false;
+    
+    for (var i = 2; i * i <= limit; i++) {
+        if (sieve[i]) {
+            for (var j = i * i; j <= limit; j += i) {
+                sieve[j] = false;
+            }
+        }
+    }
+    
+    var primes = [];
+    for (var i = 2; i <= limit; i++) {
+        if (sieve[i]) primes.push(i);
+    }
+    return primes;
+}
+
+var primes = sieveOfEratosthenes(100);
+console.log('Primes up to 100:');
+console.log('  ' + primes.join(', '));
+console.log('  Count: ' + primes.length + ' primes\n');
+
+// ===========================================
+// PRIME FACTORIZATION
+// ===========================================
+
+console.log('='.repeat(50));
+console.log('Prime Factorization:');
+console.log('='.repeat(50) + '\n');
+
+function factorize(n) {
+    var factors = [];
+    var d = 2;
+    
+    while (n > 1) {
+        while (n % d === 0) {
+            factors.push(d);
+            n = n / d;
+        }
+        d++;
+        if (d * d > n && n > 1) {
+            factors.push(n);
+            break;
+        }
+    }
+    
+    return factors;
+}
+
+function factorizationToString(factors) {
+    var counts = {};
+    for (var i = 0; i < factors.length; i++) {
+        counts[factors[i]] = (counts[factors[i]] || 0) + 1;
+    }
+    
+    var parts = [];
+    for (var prime in counts) {
+        if (counts.hasOwnProperty(prime)) {
+            if (counts[prime] === 1) {
+                parts.push(prime);
+            } else {
+                parts.push(prime + '^' + counts[prime]);
+            }
+        }
+    }
+    return parts.join(' × ');
+}
+
+var numbers = [12, 60, 100, 1001, 9999];
+
+console.log('Prime factorizations:');
+for (var i = 0; i < numbers.length; i++) {
+    var n = numbers[i];
+    var factors = factorize(n);
+    console.log('  ' + n + ' = ' + factorizationToString(factors));
+}
+
+// ===========================================
+// PRIMES IN TEXT ENCODING
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('Primes in Text Encoding:');
+console.log('='.repeat(50) + '\n');
+
+console.log('TinyAleph assigns primes to words:');
+console.log('  - Each word token gets a unique prime');
+console.log('  - Position encoded by prime powers');
+console.log('  - Product uniquely identifies sequence\n');
+
+var words = ['the', 'quick', 'brown', 'fox'];
+
+console.log('Word to prime mapping:');
+for (var i = 0; i < words.length; i++) {
+    var primeArr = backend.encode(words[i]);
+    console.log('  "' + words[i] + '" → prime ' + primeArr[0]);
+}
+
+// Show ordered encoding
+var sentence = 'the quick brown fox';
+var ordered = backend.encodeOrdered(sentence);
+console.log('\nOrdered encoding of "' + sentence + '":');
+console.log('  Primes: [' + ordered.join(', ') + ']');
+
+// ===========================================
+// PRIME PROPERTIES
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('Prime Properties:');
+console.log('='.repeat(50) + '\n');
+
+// Check if prime
+function isPrime(n) {
+    if (n < 2) return false;
+    if (n === 2) return true;
+    if (n % 2 === 0) return false;
+    
+    for (var i = 3; i * i <= n; i += 2) {
+        if (n % i === 0) return false;
+    }
+    return true;
+}
+
+console.log('Primality testing:');
+var testNumbers = [17, 91, 97, 100, 101];
+for (var i = 0; i < testNumbers.length; i++) {
+    var n = testNumbers[i];
+    console.log('  ' + n + ': ' + (isPrime(n) ? 'prime' : 'composite'));
+}
+
+// Twin primes
+console.log('\nTwin primes (differ by 2):');
+var twins = [];
+for (var i = 0; i < primes.length - 1 && twins.length < 5; i++) {
+    if (primes[i + 1] - primes[i] === 2) {
+        twins.push('(' + primes[i] + ', ' + primes[i + 1] + ')');
+    }
+}
+console.log('  ' + twins.join(', '));
+
+// ===========================================
+// GCD AND LCM
+// ===========================================
+
+console.log('\n' + '='.repeat(50));
+console.log('GCD and LCM:');
+console.log('='.repeat(50) + '\n');
+
+function gcd(a, b) {
+    while (b !== 0) {
+        var t = b;
+        b = a % b;
+        a = t;
+    }
+    return a;
+}
+
+function lcm(a, b) {
+    return Math.abs(a * b) / gcd(a, b);
+}
+
+var pairs = [[12, 18], [35, 49], [100, 60]];
+
+console.log('GCD and LCM examples:');
+for (var i = 0; i < pairs.length; i++) {
+    var a = pairs[i][0];
+    var b = pairs[i][1];
+    console.log('  GCD(' + a + ', ' + b + ') = ' + gcd(a, b));
+    console.log('  LCM(' + a + ', ' + b + ') = ' + lcm(a, b));
+    console.log('');
+}
+
+// ===========================================
+// KEY TAKEAWAYS
+// ===========================================
+
+console.log('='.repeat(50));
+console.log('KEY TAKEAWAYS:');
+console.log('1. Primes are building blocks of integers');
+console.log('2. Every integer has unique prime factorization');
+console.log('3. TinyAleph maps words to primes');
+console.log('4. Products encode ordered sequences');
+console.log('5. Factorization enables structure analysis');
+console.log('6. Prime properties underpin cryptography');