@aleph-ai/tinyaleph 1.5.7 → 1.6.0

package/examples/topology/01-108-invariant.js

@@ -0,0 +1,81 @@
+/**
+ * Example 01: The 108 Invariant
+ *
+ * Demonstrates the fundamental 108 = 2² × 3³ invariant from 108bio.pdf
+ * that generates gauge symmetries and physical constants.
+ */
+
+const {
+    TWIST_108,
+    twistAngle,
+    totalTwist,
+    isTwistClosed,
+    findClosingPrimes
+} = require('../../core/prime');
+
+console.log('═══════════════════════════════════════════════════════════════');
+console.log('  The 108 Invariant: Minimal Closed-Form Twist Configuration');
+console.log('═══════════════════════════════════════════════════════════════\n');
+
+// Basic properties
+console.log('1. Basic Properties of 108\n');
+console.log(`   Value: ${TWIST_108.value}`);
+console.log(`   Factorization: ${TWIST_108.binary} × ${TWIST_108.ternary} = 2² × 3³`);
+console.log(`   Mod-30 boundary: ${TWIST_108.mod30Boundary} (prime sieve limit)\n`);
+
+// Twist angles
+console.log('2. Twist Angles (κ = 360°/p)\n');
+const fundamentalPrimes = [2, 3, 5, 7, 11, 13];
+for (const p of fundamentalPrimes) {
+    const angle = twistAngle(p);
+    console.log(`   κ(${p}) = ${angle.toFixed(2)}°`);
+}
+
+// Closure demonstration
+console.log('\n3. Twist Closure (sum must be multiple of 360°)\n');
+
+const testSets = [
+    [2, 2],           // 180 + 180 = 360
+    [2, 3, 3],        // 180 + 120 + 120 = 420 (not closed)
+    [3, 3, 3],        // 120 + 120 + 120 = 360
+    [2, 3, 3, 3],     // 180 + 120 + 120 + 120 = 540 (not closed)
+    [2, 2, 3, 3, 3],  // 180 + 180 + 120 + 120 + 120 = 720 (2 × 360)
+];
+
+for (const primes of testSets) {
+    const total = totalTwist(primes);
+    const closed = isTwistClosed(primes);
+    console.log(`   [${primes.join(', ')}] → ${total.toFixed(0)}° ${closed ? '✓ CLOSED' : '✗ open'}`);
+}
+
+// Resonance detection
+console.log('\n4. 108-Resonance Detection\n');
+const testNumbers = [54, 108, 216, 324, 100, 137];
+for (const n of testNumbers) {
+    const resonates = TWIST_108.resonates(n);
+    console.log(`   ${n} ${resonates ? '✓ resonates (n/108 = ' + n/108 + ')' : '✗ does not resonate'}`);
+}
+
+// Find primes that form closing sets
+console.log('\n5. Finding Closing Prime Sets\n');
+console.log('   Searching for primes that would close an open sequence...\n');
+
+// Start with a single prime [5] and find what would close it
+const currentSequence = [5];
+const candidates = findClosingPrimes(currentSequence);
+console.log(`   Current sequence: [${currentSequence.join(', ')}] = ${totalTwist(currentSequence).toFixed(1)}°`);
+console.log('   Top candidates to close:\n');
+for (const candidate of candidates.slice(0, 5)) {
+    console.log(`   + ${candidate.prime} → error ${candidate.error.toFixed(2)}° ${candidate.closesAt ? '✓ CLOSES' : ''}`);
+}
+
+// Physical significance
+console.log('\n6. Physical Significance\n');
+console.log('   The 108 invariant appears throughout physics:\n');
+console.log(`   • 108 = 2² × 3³ generates SU(3) × SU(2) × U(1) gauge group`);
+console.log(`   • Fine structure: α⁻¹ = 108 + 29 = 137`);
+console.log(`   • Mass ratio: 17 × 108 = 1836 (proton/electron)`);
+console.log(`   • Hindu/Buddhist: 108 beads, 108 sacred names`);
+console.log(`   • Geometry: interior angles of pentagon = 108°`);
+
+console.log('\n═══════════════════════════════════════════════════════════════\n');

package/examples/topology/02-trefoil-constants.js

@@ -0,0 +1,112 @@
+/**
+ * Example 02: Trefoil Knot and Physical Constants
+ * 
+ * Demonstrates how the Trefoil knot's topological invariants
+ * combine with the 108 invariant to derive physical constants.
+ */
+
+const {
+    Knot,
+    TREFOIL,
+    FIGURE_EIGHT,
+    CINQUEFOIL,
+    STANDARD_KNOTS,
+    PhysicalConstants
+} = require('../../core/topology');
+
+console.log('═══════════════════════════════════════════════════════════════');
+console.log('  Trefoil Knot and Physical Constant Derivation');
+console.log('═══════════════════════════════════════════════════════════════\n');
+
+// Trefoil invariants
+console.log('1. The Trefoil Knot (3₁) - Minimal Stable Structure\n');
+
+console.log('   Topological Invariants:');
+console.log(`   • Crossing number (c): ${TREFOIL.crossings}`);
+console.log(`   • Stick number (s):    ${TREFOIL.sticks}`);
+console.log(`   • Bridge number (b):   ${TREFOIL.bridge}`);
+console.log(`   • Unknotting (u):      ${TREFOIL.unknotting}`);
+
+console.log('\n   Complexity Calculation:');
+console.log(`   T = s·c - b + u`);
+console.log(`   T = ${TREFOIL.sticks}×${TREFOIL.crossings} - ${TREFOIL.bridge} + ${TREFOIL.unknotting}`);
+console.log(`   T = ${TREFOIL.sticks * TREFOIL.crossings} - ${TREFOIL.bridge} + ${TREFOIL.unknotting}`);
+console.log(`   T = ${TREFOIL.complexity()}`);
+
+// Mass ratio derivation
+console.log('\n2. Proton-Electron Mass Ratio\n');
+
+const massRatio = PhysicalConstants.protonElectronRatio();
+console.log(`   Formula: ${massRatio.formula}`);
+console.log(`   Derived value:      ${massRatio.derived}`);
+console.log(`   Experimental value: ${massRatio.experimental}`);
+console.log(`   Relative error:     ${(massRatio.relativeError * 100).toFixed(4)}%`);
+console.log(`   Interpretation: ${massRatio.interpretation}`);
+
+// Fine structure constant
+console.log('\n3. Fine Structure Constant Inverse\n');
+
+const alpha = PhysicalConstants.fineStructureInverse();
+console.log(`   Formula: ${alpha.formula}`);
+console.log(`   Derived value:      ${alpha.derived}`);
+console.log(`   Experimental value: ${alpha.experimental}`);
+console.log(`   Relative error:     ${(alpha.relativeError * 100).toFixed(4)}%`);
+console.log(`   Interpretation: ${alpha.interpretation}`);
+
+// Higgs mass
+console.log('\n4. Higgs Boson Mass\n');
+
+const higgs = PhysicalConstants.higgsMass();
+console.log(`   Formula: ${higgs.formula}`);
+console.log(`   Derived value:      ${higgs.derived} ${higgs.unit}`);
+console.log(`   Experimental value: ${higgs.experimental} ${higgs.unit}`);
+console.log(`   Relative error:     ${(higgs.relativeError * 100).toFixed(4)}%`);
+console.log(`   Interpretation: ${higgs.interpretation}`);
+
+// Compare other knots
+console.log('\n5. Comparing Different Knots\n');
+
+const knots = [TREFOIL, FIGURE_EIGHT, CINQUEFOIL];
+
+console.log('   ┌──────────────┬────────┬────────┬────────┬─────────────┐');
+console.log('   │ Knot         │ T      │ Genus  │ Prime? │ Mass Ratio  │');
+console.log('   ├──────────────┼────────┼────────┼────────┼─────────────┤');
+
+for (const knot of knots) {
+    const T = knot.complexity();
+    const genus = knot.genusLowerBound();
+    const prime = knot.isPrimeKnot() ? 'Yes' : 'No';
+    const ratio = knot.deriveMassRatio();
+    console.log(`   │ ${knot.name.padEnd(12)} │ ${T.toString().padEnd(6)} │ ${genus.toString().padEnd(6)} │ ${prime.padEnd(6)} │ ${ratio.toString().padEnd(11)} │`);
+}
+
+console.log('   └──────────────┴────────┴────────┴────────┴─────────────┘');
+
+// Framework validation
+console.log('\n6. Framework Validation\n');
+
+const validation = PhysicalConstants.validate();
+console.log('   Validation Results:');
+console.log(`   • Proton/electron ratio: ${validation.protonElectron.matches ? '✓ PASS' : '✗ FAIL'} (${(validation.protonElectron.accuracy * 100).toFixed(2)}% accurate)`);
+console.log(`   • Fine structure:        ${validation.fineStructure.matches ? '✓ PASS' : '✗ FAIL'} (${(validation.fineStructure.accuracy * 100).toFixed(2)}% accurate)`);
+console.log(`   • Higgs mass:            ${validation.higgs.matches ? '✓ PASS' : '✗ FAIL'} (${(validation.higgs.accuracy * 100).toFixed(2)}% accurate)`);
+console.log(`\n   Overall: ${validation.overallValid ? '✓ Framework validated!' : '✗ Some predictions failed'}`);
+
+// Custom knot creation
+console.log('\n7. Custom Knot Analysis\n');
+
+const customKnot = new Knot({
+    name: 'Torus(3,7)',
+    notation: 'T(3,7)',
+    crossings: 12,  // (p-1)(q-1) for torus knot
+    sticks: 14,
+    bridge: 3,
+    unknotting: 4
+});
+
+console.log(`   ${customKnot.name}:`);
+console.log(`   Complexity: ${customKnot.complexity()}`);
+console.log(`   Mass ratio: ${customKnot.deriveMassRatio()}`);
+console.log(`   Is prime: ${customKnot.isPrimeKnot()}`);
+
+console.log('\n═══════════════════════════════════════════════════════════════\n');

package/examples/topology/03-gauge-symmetry.js

@@ -0,0 +1,112 @@
+/**
+ * Example 03: Gauge Symmetry from 108
+ * 
+ * Demonstrates how 108 = 2² × 3³ generates the Standard Model
+ * gauge group SU(3) × SU(2) × U(1).
+ */
+
+const { GaugeSymmetry } = require('../../core/topology');
+const { TWIST_108, factorize } = require('../../core/prime');
+
+console.log('═══════════════════════════════════════════════════════════════');
+console.log('  Gauge Symmetry from the 108 Invariant');
+console.log('═══════════════════════════════════════════════════════════════\n');
+
+// The factorization
+console.log('1. The Factorization 108 = 2² × 3³\n');
+console.log(`   108 = ${TWIST_108.binary} × ${TWIST_108.ternary}`);
+console.log('       = 2² × 3³');
+console.log('       = 4 × 27\n');
+console.log('   This generates the complete Standard Model gauge structure.');
+
+// SU(3) - Color
+console.log('\n2. SU(3) Color Symmetry (Strong Force)\n');
+
+const su3 = GaugeSymmetry.su3();
+console.log(`   Name: ${su3.name}`);
+console.log(`   Generator: 3³ = ${su3.generator}`);
+console.log(`   Twist angle: ${su3.twistAngle}° (ternary rotation)`);
+console.log(`   Symmetry type: ${su3.symmetryType}`);
+console.log(`   Description: ${su3.description}`);
+console.log('\n   Physical interpretation:');
+console.log('   • Three color charges: red, green, blue');
+console.log('   • 120° rotation between color states');
+console.log('   • Quarks carry color, gluons carry color pairs');
+
+// SU(2) - Weak
+console.log('\n3. SU(2) Weak Isospin (Weak Force)\n');
+
+const su2 = GaugeSymmetry.su2();
+console.log(`   Name: ${su2.name}`);
+console.log(`   Generator: 2² = ${su2.generator}`);
+console.log(`   Twist angle: ${su2.twistAngle}° (binary rotation)`);
+console.log(`   Symmetry type: ${su2.symmetryType}`);
+console.log(`   Description: ${su2.description}`);
+console.log('\n   Physical interpretation:');
+console.log('   • Two isospin states: up/down');
+console.log('   • 180° rotation between weak eigenstates');
+console.log('   • W±, Z⁰ bosons mediate weak interactions');
+
+// U(1) - Electromagnetic
+console.log('\n4. U(1) Electromagnetic (EM Force)\n');
+
+const u1 = GaugeSymmetry.u1();
+console.log(`   Name: ${u1.name}`);
+console.log(`   Generator: ${u1.generator} (full 108)`);
+console.log(`   Twist angle: ${u1.twistAngle}° (complete rotation)`);
+console.log(`   Symmetry type: ${u1.symmetryType}`);
+console.log(`   Description: ${u1.description}`);
+console.log('\n   Physical interpretation:');
+console.log('   • Phase symmetry of charged particles');
+console.log('   • 360° rotation returns to same state');
+console.log('   • Photon is the gauge boson');
+
+// Full Standard Model
+console.log('\n5. Complete Standard Model Gauge Group\n');
+
+const sm = GaugeSymmetry.standardModel();
+console.log(`   Name: ${sm.name}`);
+console.log(`   Generator: ${sm.generator}`);
+console.log(`   Factorization: ${sm.factorization}`);
+console.log(`   Description: ${sm.description}`);
+
+console.log('\n   Component Summary:');
+console.log('   ┌─────────┬───────────────┬───────────┬──────────────┐');
+console.log('   │ Group   │ Force         │ Generator │ Twist Angle  │');
+console.log('   ├─────────┼───────────────┼───────────┼──────────────┤');
+for (const comp of sm.components) {
+    console.log(`   │ ${comp.name.padEnd(7)} │ ${comp.type.padEnd(13)} │ ${comp.generator.toString().padEnd(9)} │ ${comp.twistAngle.toString().padEnd(4)}°        │`);
+}
+console.log('   └─────────┴───────────────┴───────────┴──────────────┘');
+
+// Decomposing other numbers
+console.log('\n6. Gauge Decomposition of Numbers\n');
+
+const testNumbers = [108, 216, 324, 54, 72, 36, 12, 1836, 137];
+
+console.log('   Analyzing gauge structure of various numbers:\n');
+console.log('   ┌────────┬────────┬────────┬────────┬──────────────┐');
+console.log('   │ Number │ SU(3)  │ SU(2)  │ U(1)   │ 108-Resonant │');
+console.log('   ├────────┼────────┼────────┼────────┼──────────────┤');
+
+for (const n of testNumbers) {
+    const decomp = GaugeSymmetry.decompose(n);
+    const resonant = decomp.is108Resonant ? '✓' : '✗';
+    console.log(`   │ ${n.toString().padEnd(6)} │ ${decomp.su3Strength.toString().padEnd(6)} │ ${decomp.su2Strength.toString().padEnd(6)} │ ${decomp.u1Strength.toString().padEnd(6)} │ ${resonant.padEnd(12)} │`);
+}
+
+console.log('   └────────┴────────┴────────┴────────┴──────────────┘');
+
+// Physical implications
+console.log('\n7. Physical Implications\n');
+
+console.log('   The 108 factorization explains why:');
+console.log('   • The strong force has 3 color charges (from 3³)');
+console.log('   • The weak force has 2 isospin states (from 2²)');
+console.log('   • EM has 1 charge type (from full 108)');
+console.log('   • These forces unify at high energies (GUT scale)');
+console.log('\n   The 2² × 3³ structure is the minimal configuration');
+console.log('   that closes under twist operations while preserving');
+console.log('   both binary (weak) and ternary (strong) symmetries.');
+
+console.log('\n═══════════════════════════════════════════════════════════════\n');

package/examples/topology/04-free-energy-dynamics.js

@@ -0,0 +1,124 @@
+/**
+ * Example 04: Free Energy Dynamics
+ * 
+ * Demonstrates the cubic FEP dynamics from 108bio.pdf Section 4.2:
+ * dψ/dt = αψ + βψ² + γψ³
+ * 
+ * This models consciousness as minimization of epistemic surprise.
+ */
+
+const { FreeEnergyDynamics, OBSERVER_HIERARCHY, observerCapacity } = require('../../core/topology');
+
+console.log('═══════════════════════════════════════════════════════════════');
+console.log('  Free Energy Dynamics: Cubic FEP Model');
+console.log('═══════════════════════════════════════════════════════════════\n');
+
+// Create FEP dynamics
+console.log('1. The Cubic Free Energy Model\n');
+console.log('   dψ/dt = αψ + βψ² + γψ³\n');
+console.log('   Where:');
+console.log('   • ψ represents the "understanding" state');
+console.log('   • α controls linear drift');
+console.log('   • β controls bifurcation (quadratic)');
+console.log('   • γ provides stabilization (cubic)\n');
+
+const fep = new FreeEnergyDynamics(0.1, -0.5, -0.1);
+console.log(`   Parameters: α=${fep.alpha}, β=${fep.beta}, γ=${fep.gamma}`);
+
+// Find fixed points
+console.log('\n2. Fixed Points (Attractors)\n');
+
+const fixedPoints = fep.fixedPoints();
+console.log('   Fixed points of the dynamics (where dψ/dt = 0):\n');
+for (const fp of fixedPoints) {
+    const potential = fep.potential(fp.value);
+    console.log(`   ψ = ${fp.value.toFixed(4)} → ${fp.stability} (V = ${potential.toFixed(4)})`);
+}
+
+// Trajectory simulation
+console.log('\n3. Trajectory Simulation\n');
+
+const trajectory = fep.simulate(0.2, 5, 0.05);
+console.log('   Starting from ψ₀ = 0.2, simulating for t = 5:\n');
+console.log('   ┌────────┬──────────┬────────────┐');
+console.log('   │ Time   │ ψ        │ V(ψ)       │');
+console.log('   ├────────┼──────────┼────────────┤');
+
+// Sample every 20 steps
+for (let i = 0; i < trajectory.length; i += 20) {
+    const pt = trajectory[i];
+    console.log(`   │ ${pt.t.toFixed(2).padStart(6)} │ ${pt.psi.toFixed(6).padStart(8)} │ ${pt.potential.toFixed(6).padStart(10)} │`);
+}
+console.log('   └────────┴──────────┴────────────┘');
+
+// Compare different parameter regimes
+console.log('\n4. Parameter Regime Exploration\n');
+
+const regimes = [
+    { name: 'Stable focus', alpha: 0.05, beta: -0.3, gamma: -0.05 },
+    { name: 'Saddle', alpha: 0.2, beta: -0.1, gamma: -0.1 },
+    { name: 'Bistable', alpha: 0.1, beta: 0.3, gamma: -0.2 },
+    { name: 'Monostable', alpha: -0.1, beta: -0.2, gamma: -0.05 },
+];
+
+for (const regime of regimes) {
+    const dynamics = new FreeEnergyDynamics(regime.alpha, regime.beta, regime.gamma);
+    const fps = dynamics.fixedPoints();
+    const stableCount = fps.filter(fp => fp.stability === 'stable').length;
+    
+    console.log(`   ${regime.name}:`);
+    console.log(`     Parameters: α=${regime.alpha}, β=${regime.beta}, γ=${regime.gamma}`);
+    console.log(`     Fixed points: ${fps.length}, Stable: ${stableCount}\n`);
+}
+
+// Observer hierarchy
+console.log('5. Observer Hierarchy (from Table 1)\n');
+
+console.log('   Different scales of observers from 108bio.pdf:\n');
+console.log('   ┌────────────┬─────────────────────┬──────────────────────────┐');
+console.log('   │ Scale      │ Oscillators         │ Observable Behavior      │');
+console.log('   ├────────────┼─────────────────────┼──────────────────────────┤');
+
+for (const level of OBSERVER_HIERARCHY) {
+    const scale = level.scale.padEnd(10);
+    const oscillators = (level.constituentOscillators || 'N/A').padEnd(19);
+    const behavior = (level.observableBehavior || 'N/A').slice(0, 24).padEnd(24);
+    console.log(`   │ ${scale} │ ${oscillators} │ ${behavior} │`);
+}
+console.log('   └────────────┴─────────────────────┴──────────────────────────┘');
+
+// Observer capacity
+console.log('\n6. Observer Capacity Calculation\n');
+console.log('   C_obs = α·N_osc·K̄·τ⁻¹\n');
+console.log('   Where:');
+console.log('   • N_osc = number of oscillators');
+console.log('   • K̄ = mean coupling strength');
+console.log('   • τ = characteristic coherence time');
+console.log('   • α = scaling constant\n');
+
+const examples = [
+    { name: 'Neural ensemble', N: 1000, K: 0.3, tau: 0.05, alpha: 1.0 },
+    { name: 'Cognitive network', N: 10000, K: 0.5, tau: 0.2, alpha: 1.0 },
+    { name: 'Social group', N: 100, K: 0.1, tau: 10.0, alpha: 1.0 },
+];
+
+for (const ex of examples) {
+    const capacity = observerCapacity(ex.N, ex.K, ex.tau, ex.alpha);
+    console.log(`   ${ex.name}:`);
+    console.log(`     N=${ex.N}, K̄=${ex.K}, τ=${ex.tau}`);
+    console.log(`     C_obs = ${capacity.toFixed(2)}\n`);
+}
+
+// Interpretation
+console.log('7. Interpretation: Consciousness as Entropy Minimization\n');
+
+console.log('   The cubic FEP dynamics models consciousness as:');
+console.log('   1. Modal superposition → ψ represents superposed possibilities');
+console.log('   2. Entropy gradient → dψ/dt driven by surprise minimization');
+console.log('   3. Collapse to "now" → stable attractor = present moment');
+console.log('   4. Multi-scale nesting → observers at each scale');
+console.log('\n   High ψ = exploring/uncertain state');
+console.log('   Low ψ = exploiting/certain state');
+console.log('   Attractors = stable conscious states');
+
+console.log('\n═══════════════════════════════════════════════════════════════\n');

package/examples/topology/README.md

@@ -0,0 +1,129 @@
+# Topology Examples
+
+These examples demonstrate the topological invariants and physical constant derivations from the 108bio.pdf paper "Twist Eigenstates and Topological Morphogenesis".
+
+## Examples
+
+### [01-108-invariant.js](./01-108-invariant.js)
+
+The fundamental 108 = 2² × 3³ invariant:
+
+- Basic properties and factorization
+- Twist angles κ(p) = 360°/p
+- Twist closure detection
+- 108-resonance checking
+- Finding closing prime sets
+
+```bash
+node examples/topology/01-108-invariant.js
+```
+
+### [02-trefoil-constants.js](./02-trefoil-constants.js)
+
+Trefoil knot and physical constant derivation:
+
+- Knot topological invariants (crossings, sticks, bridge, unknotting)
+- Complexity calculation: T = s·c - b + u = 17
+- Proton-electron mass ratio: 17 × 108 = 1836
+- Fine structure constant: α⁻¹ = 108 + 29 = 137
+- Higgs mass: 5³ = 125 GeV
+- Framework validation
+
+```bash
+node examples/topology/02-trefoil-constants.js
+```
+
+### [03-gauge-symmetry.js](./03-gauge-symmetry.js)
+
+Standard Model gauge group from 108:
+
+- SU(3) color symmetry from 3³
+- SU(2) weak isospin from 2²
+- U(1) electromagnetic from full 108
+- Complete Standard Model structure
+- Gauge decomposition of numbers
+
+```bash
+node examples/topology/03-gauge-symmetry.js
+```
+
+### [04-free-energy-dynamics.js](./04-free-energy-dynamics.js)
+
+Free Energy Principle (FEP) dynamics:
+
+- Cubic dynamics: dψ/dt = αψ + βψ² + γψ³
+- Fixed point analysis
+- Trajectory simulation
+- Parameter regime exploration
+- Observer hierarchy
+- Observer capacity calculation
+
+```bash
+node examples/topology/04-free-energy-dynamics.js
+```
+
+## Key Concepts
+
+### The 108 Invariant
+
+The number 108 = 2² × 3³ is the minimal closed-form twist configuration:
+
+```javascript
+const { TWIST_108 } = require('@aleph-ai/tinyaleph/core/prime');
+
+// Check twist closure
+console.log(TWIST_108.isTwistClosed([3, 3, 3]));  // true (360°)
+console.log(TWIST_108.resonates(216));            // true (2 × 108)
+```
+
+### Trefoil Complexity
+
+The Trefoil knot (3₁) is the minimal stable structure:
+
+```javascript
+const { TREFOIL, PhysicalConstants } = require('@aleph-ai/tinyaleph/core/topology');
+
+console.log(TREFOIL.complexity());      // 17
+console.log(TREFOIL.deriveMassRatio()); // 1836
+
+const ratio = PhysicalConstants.protonElectronRatio();
+console.log(ratio.relativeError);       // < 0.001
+```
+
+### Gauge Symmetry
+
+108 generates the Standard Model gauge group:
+
+```javascript
+const { GaugeSymmetry } = require('@aleph-ai/tinyaleph/core/topology');
+
+const sm = GaugeSymmetry.standardModel();
+console.log(sm.name);  // 'SU(3) × SU(2) × U(1)'
+```
+
+### Free Energy Dynamics
+
+Consciousness modeled as entropy minimization:
+
+```javascript
+const { FreeEnergyDynamics } = require('@aleph-ai/tinyaleph/core/topology');
+
+const fep = new FreeEnergyDynamics(0.1, -0.5, -0.1);
+const trajectory = fep.simulate(0.2, 10, 0.01);
+const attractors = fep.fixedPoints();
+```
+
+## Running All Examples
+
+```bash
+# Run all topology examples
+for f in examples/topology/*.js; do node "$f"; done
+```
+
+## References
+
+- 108bio.pdf: "Twist Eigenstates and Topological Morphogenesis"
+- Section 2: The 108 Invariant
+- Section 3: Knot Invariants and Mass Ratios
+- Section 4: Free Energy Dynamics
+- Table 1: Observer Hierarchy

package/index.js

@@ -128,6 +128,13 @@ export const {
   partialCollapse,
   applyDecoherence,
   
+  // ALK-Kuramoto models
+  ALKKuramotoModel,
+  ALKNetworkKuramoto,
+  createALKKuramoto,
+  createALKNetworkKuramoto,
+  runBorromeanExperiment,
+  
   // Convenience functions
   hash,
   deriveKey,
@@ -169,6 +176,31 @@ export const {
   PRGraphMemory,
   applyResonanceOperator,
   
+  // Arithmetic Link Kernel (ArithmeticLinkKernels.pdf)
+  LegendreSymbol,
+  PowerResidueSymbol,
+  RedeiSymbol,
+  ArithmeticMilnorInvariant,
+  MultipleResidueSymbol,
+  ArithmeticLinkKernel,
+  ALKOperators,
+  findBorromeanPrimes,
+  computeLegendreMatrix,
+  quickBorromeanCheck,
+  
+  // Alexander Modules (CompleteAlexanderModules.pdf)
+  LaurentPolynomial,
+  FittingIdeal,
+  CrowellSequence,
+  AlexanderModule,
+  ModuleSignature,
+  SignatureMemory,
+  SignatureExtractor,
+  createAlexanderModule,
+  extractSignature,
+  createSignatureMemory,
+  createSignatureExtractor,
+  
   // Sub-modules
   core,
   physics,