@aleph-ai/tinyaleph 1.5.6 → 1.6.0

package/examples/demo-two-layer.js

@@ -0,0 +1,196 @@
+/**
+ * Demo: Two-Layer Semantic System
+ * 
+ * Shows how the same MEANING (primes) can be expressed 
+ * with different WORDS based on register/style biases
+ */
+
+const { TwoLayerEngine } = require('../backends/semantic/two-layer');
+
+console.log('╔═══════════════════════════════════════════════════════════════╗');
+console.log('║       Two-Layer Semantic System Demo                          ║');
+console.log('║       Layer 1: Prime-Based Meaning (Invariant)               ║');
+console.log('║       Layer 2: Word Selection with Bias (Variable)           ║');
+console.log('╚═══════════════════════════════════════════════════════════════╝\n');
+
+const engine = new TwoLayerEngine({
+  core: { dimension: 16 }
+});
+
+// ============================================
+// 1. Same Meaning, Different Registers
+// ============================================
+console.log('┌───────────────────────────────────────────────────────────────┐');
+console.log('│  SAME MEANING, DIFFERENT REGISTERS                           │');
+console.log('└───────────────────────────────────────────────────────────────┘\n');
+
+const input1 = 'truth wisdom knowledge';
+console.log(`Input: "${input1}"\n`);
+
+// Process in formal register
+engine.useRegister('formal');
+const formal = engine.process(input1);
+console.log(`  Formal:   "${formal.surface.words.join(' ')}"`);
+
+// Transform to casual
+const toCasual = engine.transform(input1, 'casual');
+console.log(`  Casual:   "${toCasual.transformed}"`);
+
+// Transform to technical
+const toTechnical = engine.transform(input1, 'technical');
+console.log(`  Technical: "${toTechnical.transformed}"`);
+
+// Transform to poetic
+const toPoetic = engine.transform(input1, 'poetic');
+console.log(`  Poetic:   "${toPoetic.transformed}"`);
+
+console.log(`\n  Same meaning primes: [${formal.meaning.primes.slice(0,8).join(', ')}...]`);
+console.log(`  Meaning entropy: ${formal.meaning.entropy.toFixed(3)}`);
+
+// ============================================
+// 2. Cross-Register Translation
+// ============================================
+console.log('\n┌───────────────────────────────────────────────────────────────┐');
+console.log('│  CROSS-REGISTER TRANSLATION                                   │');
+console.log('└───────────────────────────────────────────────────────────────┘\n');
+
+// Casual to Formal
+const casualInput = 'love';
+console.log(`Translating casual → formal:`);
+console.log(`  "${casualInput}" → `, engine.translate(casualInput, 'casual', 'formal').translated);
+
+// Formal to Casual  
+const formalInput = 'contemplate';
+console.log(`\nTranslating formal → casual:`);
+console.log(`  "${formalInput}" → `, engine.translate(formalInput, 'formal', 'casual').translated);
+
+// Technical to Poetic
+const techInput = 'analyze';
+console.log(`\nTranslating technical → poetic:`);
+console.log(`  "${techInput}" → `, engine.translate(techInput, 'technical', 'poetic').translated);
+
+// ============================================
+// 3. Context-Sensitive Selection
+// ============================================
+console.log('\n┌───────────────────────────────────────────────────────────────┐');
+console.log('│  CONTEXT-SENSITIVE WORD SELECTION                             │');
+console.log('└───────────────────────────────────────────────────────────────┘\n');
+
+// Set context and see how it affects word choice
+engine.useRegister('formal');
+
+console.log('Same primes [7, 11, 13] ("truth") in different contexts:\n');
+
+engine.surfaces.pushContext('academic');
+const academic = engine.surfaces.decode([7, 11, 13], { deterministic: true });
+engine.surfaces.popContext();
+console.log(`  Context: academic   → "${academic}"`);
+
+engine.surfaces.pushContext('legal');
+const legal = engine.surfaces.decode([7, 11, 13], { deterministic: true });
+engine.surfaces.popContext();
+console.log(`  Context: legal      → "${legal}"`);
+
+engine.surfaces.pushContext('archaic');
+const archaic = engine.surfaces.decode([7, 11, 13], { deterministic: true });
+engine.surfaces.popContext();
+console.log(`  Context: archaic    → "${archaic}"`);
+
+// ============================================
+// 4. The Two-Layer Architecture
+// ============================================
+console.log('\n┌───────────────────────────────────────────────────────────────┐');
+console.log('│  THE TWO-LAYER ARCHITECTURE                                   │');
+console.log('└───────────────────────────────────────────────────────────────┘\n');
+
+console.log(`
+            INPUT TEXT
+                │
+                ▼
+    ┌─────────────────────┐
+    │   LAYER 1: CORE     │
+    │   ─────────────     │
+    │  Tokenize → Primes  │
+    │  Non-commutative    │
+    │  multiplication     │   ← INVARIANT MEANING
+    │        ↓            │
+    │  Hypercomplex       │
+    │  State Vector       │
+    └──────────┬──────────┘
+               │
+               │ [primes]
+               ▼
+    ┌─────────────────────┐
+    │   LAYER 2: SURFACE  │
+    │   ───────────────   │
+    │  Prime → Word       │
+    │  candidates         │
+    │        ↓            │
+    │  Apply biases:      │   ← VARIABLE EXPRESSION
+    │  • Register         │
+    │  • Context          │
+    │  • Recency          │
+    │  • User preference  │
+    │        ↓            │
+    │  Select best word   │
+    └──────────┬──────────┘
+               │
+               ▼
+          OUTPUT TEXT
+`);
+
+// ============================================
+// 5. Probabilistic vs Deterministic Selection
+// ============================================
+console.log('\n┌───────────────────────────────────────────────────────────────┐');
+console.log('│  PROBABILISTIC WORD SELECTION                                 │');
+console.log('└───────────────────────────────────────────────────────────────┘\n');
+
+console.log('10 samples of [2, 3, 5] ("love") in casual register:');
+engine.useRegister('casual');
+
+const samples = [];
+for (let i = 0; i < 10; i++) {
+  samples.push(engine.surfaces.decode([2, 3, 5], { deterministic: false }));
+}
+console.log(`  ${samples.join(', ')}\n`);
+
+console.log('(Probabilistic selection adds natural variety)');
+
+// ============================================
+// 6. Available Registers
+// ============================================
+console.log('\n┌───────────────────────────────────────────────────────────────┐');
+console.log('│  AVAILABLE REGISTERS                                          │');
+console.log('└───────────────────────────────────────────────────────────────┘\n');
+
+const registers = engine.getRegisters();
+console.log(`  Registers: ${registers.join(', ')}\n`);
+
+for (const reg of registers) {
+  const example = engine.transform('good think', reg);
+  console.log(`  ${reg.padEnd(12)} → "${example.transformed}"`);
+}
+
+// ============================================
+// Summary
+// ============================================
+console.log('\n╔═══════════════════════════════════════════════════════════════╗');
+console.log('║                     KEY INSIGHTS                               ║');
+console.log('╠═══════════════════════════════════════════════════════════════╣');
+console.log('║                                                               ║');
+console.log('║  1. MEANING (primes) is universal and invariant               ║');
+console.log('║     - Same [7,11,13] = "truth" in all registers               ║');
+console.log('║                                                               ║');
+console.log('║  2. WORDS are local and variable                              ║');
+console.log('║     - "truth", "verity", "real talk" = same primes            ║');
+console.log('║                                                               ║');
+console.log('║  3. BIAS controls word selection                              ║');
+console.log('║     - Register (formal/casual/technical/poetic)               ║');
+console.log('║     - Context (academic, legal, romantic, etc.)               ║');
+console.log('║     - Recency (variety vs. consistency)                       ║');
+console.log('║                                                               ║');
+console.log('║  4. This is how TRANSLATION should work:                      ║');
+console.log('║     Word₁ → Primes → Word₂ (meaning-preserving)               ║');
+console.log('║                                                               ║');
+console.log('╚═══════════════════════════════════════════════════════════════╝\n');

package/examples/discrete/01-integer-sine-table.js

@@ -0,0 +1,120 @@
+/**
+ * Example 01: Integer Sine Tables
+ * 
+ * Demonstrates the discrete phase dynamics from discrete.pdf using
+ * integer sine tables for deterministic phase computation.
+ */
+
+const { INT_SINE_TABLE, computeHistogramCoherence } = require('../../apps/sentient/lib/prsc');
+
+console.log('═══════════════════════════════════════════════════════════════');
+console.log('  Integer Sine Tables for Discrete Phase Dynamics');
+console.log('═══════════════════════════════════════════════════════════════\n');
+
+// Basic sine table properties
+console.log('1. Integer Sine Table (M=256)\n');
+console.log('   From discrete.pdf: Pre-computed integer sine values');
+console.log('   for deterministic phase dynamics.\n');
+
+console.log(`   Table size: ${INT_SINE_TABLE.length} entries`);
+console.log(`   Range: [${Math.min(...INT_SINE_TABLE)}, ${Math.max(...INT_SINE_TABLE)}]`);
+
+// Sample values
+console.log('\n   Sample values (phase → sine):\n');
+console.log('   ┌───────────┬───────────┬──────────────┐');
+console.log('   │ Index     │ Phase (°) │ sin(phase)   │');
+console.log('   ├───────────┼───────────┼──────────────┤');
+
+const sampleIndices = [0, 32, 64, 96, 128, 160, 192, 224, 255];
+for (const i of sampleIndices) {
+    const phase = (i / 256 * 360).toFixed(1);
+    const value = INT_SINE_TABLE[i];
+    const normalized = (value / 127).toFixed(4);
+    console.log(`   │ ${i.toString().padStart(9)} │ ${phase.padStart(9)} │ ${normalized.padStart(12)} │`);
+}
+console.log('   └───────────┴───────────┴──────────────┘');
+
+// Phase accumulator simulation
+console.log('\n2. Phase Accumulator Simulation\n');
+
+function simulatePhaseAccumulator(frequency, steps) {
+    const history = [];
+    let phase = 0;
+    
+    for (let t = 0; t < steps; t++) {
+        const idx = Math.floor(phase) & 0xFF;  // Mod 256
+        const sine = INT_SINE_TABLE[idx];
+        history.push({ t, phase: idx, sine, normalized: sine / 127 });
+        phase = (phase + frequency) % 256;
+    }
+    
+    return history;
+}
+
+const freq = 17;  // Prime frequency for interesting dynamics
+const simulation = simulatePhaseAccumulator(freq, 16);
+
+console.log(`   Frequency: ${freq} (phase increment per step)`);
+console.log('\n   ┌──────┬───────────┬─────────────┐');
+console.log('   │ Step │ Phase Idx │ Sine Output │');
+console.log('   ├──────┼───────────┼─────────────┤');
+
+for (const step of simulation) {
+    console.log(`   │ ${step.t.toString().padStart(4)} │ ${step.phase.toString().padStart(9)} │ ${step.normalized.toFixed(4).padStart(11)} │`);
+}
+console.log('   └──────┴───────────┴─────────────┘');
+
+// Histogram coherence
+console.log('\n3. Histogram Coherence\n');
+console.log('   C_bin(t) = max_k(b_k(t)) / |P|');
+console.log('   Measures how concentrated phases are in a single bin.\n');
+
+// Generate random phases and compute coherence
+const randomPhases = Array.from({ length: 32 }, () => Math.random() * 2 * Math.PI);
+const coherentPhases = Array.from({ length: 32 }, (_, i) => Math.PI + 0.1 * (Math.random() - 0.5));
+const bimodalPhases = Array.from({ length: 32 }, (_, i) => 
+    i < 16 ? 0.5 + 0.1 * Math.random() : 2.5 + 0.1 * Math.random()
+);
+
+const randomCoherence = computeHistogramCoherence(randomPhases);
+const coherentCoherence = computeHistogramCoherence(coherentPhases);
+const bimodalCoherence = computeHistogramCoherence(bimodalPhases);
+
+console.log('   ┌───────────────────┬────────────┬──────────────┬─────────────┐');
+console.log('   │ Distribution      │ Coherence  │ Max Count    │ Entropy     │');
+console.log('   ├───────────────────┼────────────┼──────────────┼─────────────┤');
+console.log(`   │ Random            │ ${randomCoherence.coherence.toFixed(4).padStart(10)} │ ${randomCoherence.maxCount.toString().padStart(12)} │ ${randomCoherence.entropy.toFixed(4).padStart(11)} │`);
+console.log(`   │ Coherent (peaked) │ ${coherentCoherence.coherence.toFixed(4).padStart(10)} │ ${coherentCoherence.maxCount.toString().padStart(12)} │ ${coherentCoherence.entropy.toFixed(4).padStart(11)} │`);
+console.log(`   │ Bimodal           │ ${bimodalCoherence.coherence.toFixed(4).padStart(10)} │ ${bimodalCoherence.maxCount.toString().padStart(12)} │ ${bimodalCoherence.entropy.toFixed(4).padStart(11)} │`);
+console.log('   └───────────────────┴────────────┴──────────────┴─────────────┘');
+
+// Phase distribution visualization
+console.log('\n4. Phase Distribution (ASCII Histogram)\n');
+
+function visualizeHistogram(binCounts, label) {
+    const maxCount = Math.max(...binCounts);
+    const scale = 40 / maxCount;
+    
+    console.log(`   ${label}:`);
+    for (let i = 0; i < binCounts.length; i++) {
+        const bar = '█'.repeat(Math.round(binCounts[i] * scale));
+        console.log(`   Bin ${i}: ${bar} (${binCounts[i]})`);
+    }
+}
+
+console.log('   Random phases:');
+const randomHist = randomCoherence.binCounts;
+visualizeHistogram(randomHist, 'Random');
+
+console.log('\n   Coherent phases:');
+visualizeHistogram(coherentCoherence.binCounts, 'Coherent');
+
+// Application notes
+console.log('\n5. Application in Discrete HQE\n');
+console.log('   Integer sine tables enable:');
+console.log('   • Deterministic phase evolution (no floating-point drift)');
+console.log('   • Efficient hardware implementation (lookup tables)');
+console.log('   • Reproducible dynamics across nodes');
+console.log('   • Histogram coherence for sync detection');
+
+console.log('\n═══════════════════════════════════════════════════════════════\n');

package/examples/discrete/02-codebook-tunneling.js

@@ -0,0 +1,118 @@
+/**
+ * Example 02: Codebook Tunneling
+ * 
+ * Demonstrates the 64-attractor codebook from discrete.pdf for
+ * controlled state transitions via tunneling.
+ */
+
+const { SMF_CODEBOOK, nearestCodebookAttractor, codebookTunnel } = require('../../apps/sentient/lib/smf');
+
+console.log('═══════════════════════════════════════════════════════════════');
+console.log('  64-Attractor Codebook and Tunneling');
+console.log('═══════════════════════════════════════════════════════════════\n');
+
+// Codebook structure
+console.log('1. SMF Codebook Structure (64 Attractors)\n');
+console.log('   From discrete.pdf: Pre-defined attractor states for');
+console.log('   controlled tunneling in the Sedenion Memory Field.\n');
+
+console.log(`   Total attractors: ${SMF_CODEBOOK.length}`);
+
+// Group by type
+const byType = {};
+for (const entry of SMF_CODEBOOK) {
+    byType[entry.type] = (byType[entry.type] || 0) + 1;
+}
+
+console.log('\n   Distribution by type:');
+for (const [type, count] of Object.entries(byType)) {
+    console.log(`   • ${type}: ${count} attractors`);
+}
+
+// Sample attractors
+console.log('\n2. Sample Attractors\n');
+console.log('   ┌─────┬────────────────┬────────────────────────┬───────────────┐');
+console.log('   │ ID  │ Type           │ Active Axes            │ State         │');
+console.log('   ├─────┼────────────────┼────────────────────────┼───────────────┤');
+
+for (const entry of SMF_CODEBOOK.slice(0, 10)) {
+    const axes = entry.axes.slice(0, 4).join(', ') + (entry.axes.length > 4 ? '...' : '');
+    const state = entry.state.slice(0, 3).join(', ') + '...';
+    console.log(`   │ ${entry.id.toString().padStart(3)} │ ${entry.type.padEnd(14)} │ ${axes.padEnd(22)} │ ${state.padEnd(13)} │`);
+}
+console.log('   └─────┴────────────────┴────────────────────────┴───────────────┘');
+
+// Finding nearest attractor
+console.log('\n3. Finding Nearest Attractor\n');
+
+// Create test states
+const testStates = [
+    { name: 'Coherent', s: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] },
+    { name: 'Random',   s: Array.from({ length: 16 }, () => Math.random() * 2 - 1) },
+    { name: 'Sparse',   s: [0.5, 0.5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.3, 0] },
+];
+
+console.log('   Finding nearest codebook attractor for test states:\n');
+
+for (const test of testStates) {
+    const nearest = nearestCodebookAttractor(test);
+    if (nearest) {
+        console.log(`   ${test.name} state → Attractor ${nearest.entry.id} (${nearest.entry.type})`);
+        console.log(`     Distance: ${nearest.distance.toFixed(4)}`);
+    } else {
+        console.log(`   ${test.name} state → No attractor found`);
+    }
+}
+
+// Codebook tunneling
+console.log('\n4. Codebook Tunneling\n');
+console.log('   Controlled state transitions via tunneling:\n');
+
+// Create an initial state
+const initialState = { s: [0.8, 0.2, 0.1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] };
+
+// Try tunneling with different parameters
+const tunnelingTests = [
+    { rate: 0.1, threshold: 0.3 },
+    { rate: 0.5, threshold: 0.5 },
+    { rate: 0.9, threshold: 0.7 },
+];
+
+for (const params of tunnelingTests) {
+    const result = codebookTunnel(initialState, params.rate, params.threshold);
+    
+    console.log(`   Rate=${params.rate}, Threshold=${params.threshold}:`);
+    if (result.tunneled) {
+        console.log(`     ✓ Tunneled to attractor ${result.targetId} (${result.targetType})`);
+        console.log(`     Blend factor: ${result.blendFactor.toFixed(3)}`);
+    } else {
+        console.log(`     ✗ No tunnel (random check failed or no suitable attractor)`);
+    }
+}
+
+// Attractor types explained
+console.log('\n5. Attractor Types\n');
+
+console.log('   • basis:      Single axis activation (pure modes)');
+console.log('   • dual:       Two-axis correlation states');
+console.log('   • triad:      Three-axis relationships');
+console.log('   • quad:       Four-axis complex patterns');
+console.log('   • harmonic:   Resonant frequency patterns');
+console.log('   • modular:    Modular arithmetic relationships');
+
+// Tunneling in practice
+console.log('\n6. Tunneling in Practice\n');
+
+console.log('   Codebook tunneling enables:');
+console.log('   • Controlled phase transitions between stable states');
+console.log('   • Escape from local minima during learning');
+console.log('   • Structured exploration of semantic space');
+console.log('   • Deterministic behavior for distributed consensus');
+
+console.log('\n   Parameters:');
+console.log('   • rate: Probability of attempting a tunnel');
+console.log('   • threshold: Minimum distance to trigger tunneling');
+console.log('   • Higher rate = more frequent transitions');
+console.log('   • Higher threshold = only tunnel from far states');
+
+console.log('\n═══════════════════════════════════════════════════════════════\n');

package/examples/discrete/03-canonical-fusion.js

@@ -0,0 +1,135 @@
+/**
+ * Example 03: Canonical Fusion Selection
+ * 
+ * Demonstrates deterministic FUSE(p,q,r) selection from discrete.pdf
+ * using the canonical triad ordering constraint.
+ */
+
+const { 
+    canonicalTriad, 
+    canonicalFusion, 
+    canonicalTriadForTarget, 
+    verifyCanonical 
+} = require('../../apps/sentient/lib/prime-calculus');
+
+console.log('═══════════════════════════════════════════════════════════════');
+console.log('  Canonical Fusion Selection');
+console.log('═══════════════════════════════════════════════════════════════\n');
+
+// The problem with non-canonical fusion
+console.log('1. The Non-Determinism Problem\n');
+console.log('   Given target prime P, many (p, q, r) triads satisfy p + q + r = P:');
+console.log('   • 19 = 3 + 5 + 11 = 3 + 7 + 9 = 5 + 7 + 7 = ...');
+console.log('   • 29 = 3 + 7 + 19 = 5 + 7 + 17 = 5 + 11 + 13 = ...');
+console.log('\n   Which one to choose? Canonical ordering provides determinism.\n');
+
+// Canonical ordering
+console.log('2. Canonical Ordering\n');
+console.log('   Definition: A triad (p, q, r) is canonical if:');
+console.log('   1. p ≤ q ≤ r (non-decreasing order)');
+console.log('   2. All are prime');
+console.log('   3. p is the smallest possible first element');
+console.log('   4. Given p, q is the smallest possible second element\n');
+
+// Verify triads
+const testTriads = [
+    [3, 5, 11],    // 19 - canonical
+    [5, 3, 11],    // 19 - not canonical (order)
+    [11, 5, 3],    // 19 - not canonical (order)
+    [2, 2, 2],     // 6 - not prime sum
+    [2, 3, 2],     // 7 - not ordered
+];
+
+console.log('   Testing triad canonicity:\n');
+console.log('   ┌─────────────────┬───────────┬──────────────────────┐');
+console.log('   │ Triad           │ Sum       │ Canonical?           │');
+console.log('   ├─────────────────┼───────────┼──────────────────────┤');
+
+for (const triad of testTriads) {
+    const sum = triad.reduce((a, b) => a + b, 0);
+    const result = verifyCanonical(triad);
+    const status = result.isCanonical ? '✓ Yes' : `✗ No (${result.reason})`;
+    console.log(`   │ (${triad.join(', ')})`.padEnd(18) + `│ ${sum.toString().padEnd(9)} │ ${status.slice(0, 20).padEnd(20)} │`);
+}
+console.log('   └─────────────────┴───────────┴──────────────────────┘');
+
+// Finding canonical triads
+console.log('\n3. Finding Canonical Triads for Target Primes\n');
+
+const targetPrimes = [7, 11, 13, 17, 19, 23, 29, 31, 37, 41];
+
+console.log('   ┌────────┬─────────────────┬───────────────────────┐');
+console.log('   │ Target │ Canonical Triad │ Verification          │');
+console.log('   ├────────┼─────────────────┼───────────────────────┤');
+
+for (const target of targetPrimes) {
+    const triad = canonicalTriadForTarget(target);
+    if (triad) {
+        const verification = verifyCanonical(triad);
+        const status = verification.isCanonical ? '✓ Verified' : '✗ Failed';
+        console.log(`   │ ${target.toString().padEnd(6)} │ (${triad.join(', ')})`.padEnd(27) + `│ ${status.padEnd(21)} │`);
+    } else {
+        console.log(`   │ ${target.toString().padEnd(6)} │ (none)`.padEnd(27) + `│ No valid decomposition │`);
+    }
+}
+console.log('   └────────┴─────────────────┴───────────────────────┘');
+
+// Canonical fusion operation
+console.log('\n4. Canonical Fusion Operation\n');
+
+console.log('   FUSE(p, q, r) automatically:');
+console.log('   1. Reorders arguments to canonical form');
+console.log('   2. Verifies sum is prime');
+console.log('   3. Returns fusion result\n');
+
+const fusionTests = [
+    [5, 3, 11],    // Will be reordered to (3, 5, 11)
+    [11, 7, 5],    // Will be reordered to (5, 7, 11)
+    [2, 2, 3],     // Sum = 7 (prime)
+];
+
+for (const [p, q, r] of fusionTests) {
+    const result = canonicalFusion(p, q, r);
+    if (result.success) {
+        console.log(`   FUSE(${p}, ${q}, ${r}):`);
+        console.log(`     Canonical form: (${result.canonical.join(', ')})`);
+        console.log(`     Result: ${result.result}\n`);
+    } else {
+        console.log(`   FUSE(${p}, ${q}, ${r}): Failed - ${result.reason}\n`);
+    }
+}
+
+// Uniqueness guarantee
+console.log('5. Uniqueness Guarantee\n');
+
+console.log('   For any prime P with a valid decomposition,');
+console.log('   canonical selection returns a UNIQUE triad.\n');
+
+// Show that different orderings give same canonical result
+const target = 19;
+const orderings = [
+    [3, 5, 11],
+    [5, 3, 11],
+    [11, 3, 5],
+    [11, 5, 3],
+    [3, 11, 5],
+    [5, 11, 3],
+];
+
+console.log(`   All orderings of 3+5+11 = ${target}:\n`);
+
+for (const ordering of orderings) {
+    const canonical = canonicalTriad(ordering);
+    console.log(`   (${ordering.join(', ')}) → canonical: (${canonical.join(', ')})`);
+}
+
+// Applications
+console.log('\n6. Applications\n');
+
+console.log('   Canonical fusion enables:');
+console.log('   • Deterministic distributed consensus');
+console.log('   • Reproducible semantic transformations');
+console.log('   • Unique normal forms for proofs');
+console.log('   • Consistent cross-node behavior');
+
+console.log('\n═══════════════════════════════════════════════════════════════\n');