@aleph-ai/tinyaleph 1.5.7 → 1.6.0

package/examples/03-quantum-coin.js

@@ -0,0 +1,136 @@
+/**
+ * @example Quantum Coin Flip
+ * @description Create a superposition, measure, and see quantum randomness
+ * 
+ * This example demonstrates TinyAleph's scientific backend for
+ * quantum computing simulation. It shows:
+ * - Creating quantum superposition states
+ * - Applying quantum gates
+ * - Measurement and collapse
+ * - True quantum randomness
+ */
+
+const { ScientificBackend, Hypercomplex } = require('../modular');
+
+// ===========================================
+// SETUP
+// ===========================================
+
+// Create a scientific backend for quantum simulation
+const backend = new ScientificBackend({ dimension: 16 });
+
+// ===========================================
+// QUANTUM COIN FLIP
+// ===========================================
+
+console.log('TinyAleph Quantum Coin Flip Example');
+console.log('====================================\n');
+
+// Start with |0⟩ state (classical "heads up" coin)
+let zeroPrimes = backend.encode('|0⟩');
+let zeroState = backend.primesToState(zeroPrimes);
+
+console.log('Initial state: |0⟩ (coin heads up)');
+console.log('Primes:', zeroPrimes);
+console.log('First 4 components:', zeroState.c.slice(0, 4).map(c => c.toFixed(3)).join(', '));
+
+// Apply Hadamard gate to create superposition
+// H|0⟩ = (|0⟩ + |1⟩) / √2
+const superpositionPrimes = backend.applyGate(zeroPrimes, 'H');
+const superpositionState = backend.primesToState(superpositionPrimes);
+
+console.log('\nAfter Hadamard gate: |+⟩ = (|0⟩ + |1⟩)/√2 (coin spinning!)');
+console.log('Primes:', superpositionPrimes);
+console.log('First 4 components:', superpositionState.c.slice(0, 4).map(c => c.toFixed(3)).join(', '));
+
+// ===========================================
+// MULTIPLE COIN FLIPS
+// ===========================================
+
+console.log('\n====================================');
+console.log('FLIPPING THE QUANTUM COIN 10 TIMES');
+console.log('====================================\n');
+
+const results = [];
+
+for (let i = 0; i < 10; i++) {
+    // Create fresh |0⟩ state
+    const coinPrimes = backend.encode('|0⟩');
+    
+    // Apply Hadamard to create superposition
+    const spinningPrimes = backend.applyGate(coinPrimes, 'H');
+    const spinningState = backend.primesToState(spinningPrimes);
+    
+    // Measure (collapse the superposition)
+    const measurement = backend.measure(spinningState);
+    
+    // Interpret result
+    const outcome = measurement.outcome === 0 ? 'Heads' : 'Tails';
+    results.push(outcome);
+    
+    console.log(`Flip ${i + 1}: ${outcome} (probability: ${(measurement.probability * 100).toFixed(0)}%)`);
+}
+
+// Count results
+const heads = results.filter(r => r === 'Heads').length;
+const tails = results.filter(r => r === 'Tails').length;
+
+console.log('\n------------------------------------');
+console.log(`Results: ${heads} Heads, ${tails} Tails`);
+console.log(`Ratio: ${(heads / results.length * 100).toFixed(0)}% / ${(tails / results.length * 100).toFixed(0)}%`);
+
+// ===========================================
+// QUANTUM VS CLASSICAL
+// ===========================================
+
+console.log('\n====================================');
+console.log('QUANTUM VS CLASSICAL RANDOMNESS');
+console.log('====================================\n');
+
+// Classical: no superposition = deterministic
+console.log('Classical coin (no Hadamard, always |0⟩):');
+for (let i = 0; i < 3; i++) {
+    const classicalPrimes = backend.encode('|0⟩');
+    const classicalState = backend.primesToState(classicalPrimes);
+    const result = backend.measure(classicalState);
+    console.log(`  Flip ${i + 1}: ${result.outcome === 0 ? 'Heads' : 'Tails'} (prob: ${(result.probability * 100).toFixed(0)}%)`);
+}
+
+// Quantum: superposition gives randomness
+console.log('\nQuantum coin (with Hadamard):');
+for (let i = 0; i < 3; i++) {
+    const qCoinPrimes = backend.encode('|0⟩');
+    const qSpinningPrimes = backend.applyGate(qCoinPrimes, 'H');
+    const qSpinningState = backend.primesToState(qSpinningPrimes);
+    const qResult = backend.measure(qSpinningState);
+    console.log(`  Flip ${i + 1}: ${qResult.outcome === 0 ? 'Heads' : 'Tails'} (prob: ${(qResult.probability * 100).toFixed(0)}%)`);
+}
+
+// ===========================================
+// BELL STATE (ENTANGLEMENT)
+// ===========================================
+
+console.log('\n====================================');
+console.log('BONUS: BELL STATE (Entanglement)');
+console.log('====================================\n');
+
+const bellPrimes = backend.createEntangledPair('Φ+');
+const bellState = backend.primesToState(bellPrimes);
+const bellName = backend.decode(bellPrimes);
+
+console.log('Bell state |Φ+⟩ (maximally entangled):');
+console.log('  Primes:', bellPrimes);
+console.log('  Decoded:', bellName);
+console.log('  Components:', bellState.c.slice(0, 4).map(c => c.toFixed(3)).join(', '));
+
+// ===========================================
+// KEY TAKEAWAYS
+// ===========================================
+
+console.log('\n====================================');
+console.log('KEY TAKEAWAYS:');
+console.log('1. |0⟩ and |1⟩ are basis states (like Heads/Tails)');
+console.log('2. Hadamard gate creates superposition |+⟩');
+console.log('3. Measurement collapses superposition probabilistically');
+console.log('4. Each measurement is genuinely random');
+console.log('5. Bell states demonstrate quantum entanglement');

package/examples/05-symbolic-resonance.js

@@ -0,0 +1,146 @@
+/**
+ * Example: Golden Ratio Resonance
+ * 
+ * Demonstrates the resonance calculator and its ability to detect
+ * naturally harmonic relationships between primes based on the golden ratio.
+ */
+
+const {
+  ResonanceCalculator,
+  resonanceSignature,
+  findFibonacciSequences,
+  PHI,
+  calculateResonance,
+  findGoldenPairs
+} = require('../core');
+
+console.log('='.repeat(60));
+console.log('Golden Ratio Resonance Calculator');
+console.log('='.repeat(60));
+console.log(`\nGolden Ratio (φ): ${PHI.toFixed(10)}`);
+
+// ─────────────────────────────────────────────────────────────────
+// Basic Resonance Calculation
+// ─────────────────────────────────────────────────────────────────
+
+console.log('\n1. Basic Resonance Between Primes');
+console.log('-'.repeat(40));
+
+const pairs = [
+  [2, 3],
+  [3, 5],  // Fibonacci pair - ratio ≈ 1.667
+  [5, 8],  // Fibonacci pair - ratio = 1.6
+  [7, 11],
+  [11, 13]
+];
+
+for (const [p1, p2] of pairs) {
+  const r = calculateResonance(p1, p2);
+  const ratio = p2 / p1;
+  const isGolden = Math.abs(ratio - PHI) < 0.1;
+  console.log(
+    `  ${p1} × ${p2}: ratio=${ratio.toFixed(3)}, ` +
+    `resonance=${r.toFixed(4)}${isGolden ? ' ★ golden!' : ''}`
+  );
+}
+
+// ─────────────────────────────────────────────────────────────────
+// Find Golden Pairs
+// ─────────────────────────────────────────────────────────────────
+
+console.log('\n2. Golden Ratio Pairs (First 20 Primes)');
+console.log('-'.repeat(40));
+
+const first20 = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71];
+const goldenPairs = findGoldenPairs(first20);
+
+if (goldenPairs.length === 0) {
+  console.log('  No exact golden ratio pairs found (φ threshold: 0.1)');
+} else {
+  for (const pair of goldenPairs.slice(0, 5)) {
+    console.log(`  ${pair.p1}/${pair.p2} = ${pair.ratio.toFixed(5)} (resonance: ${pair.resonance.toFixed(4)})`);
+  }
+}
+
+// Fibonacci numbers for comparison
+console.log('\n  Fibonacci numbers for reference:');
+const fib = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89];
+for (let i = 1; i < fib.length - 1; i++) {
+  const ratio = fib[i + 1] / fib[i];
+  console.log(`    ${fib[i]}/${fib[i+1]} = ${ratio.toFixed(5)}`);
+}
+
+// ─────────────────────────────────────────────────────────────────
+// Resonance Signature
+// ─────────────────────────────────────────────────────────────────
+
+console.log('\n3. Resonance Signatures');
+console.log('-'.repeat(40));
+
+const sets = [
+  { name: 'Small primes', primes: [2, 3, 5, 7] },
+  { name: 'Twin primes', primes: [3, 5, 11, 13, 17, 19] },
+  { name: 'Large primes', primes: [97, 101, 103, 107, 109] },
+  { name: 'Fibonacci primes', primes: [2, 3, 5, 13, 89, 233] }
+];
+
+for (const set of sets) {
+  const sig = resonanceSignature(set.primes);
+  console.log(`  ${set.name}: mean=${sig.mean.toFixed(4)}, variance=${sig.variance.toFixed(6)}, goldenPairs=${sig.goldenCount}`);
+}
+
+// ─────────────────────────────────────────────────────────────────
+// Resonance Matrix
+// ─────────────────────────────────────────────────────────────────
+
+console.log('\n4. Resonance Matrix (First 5 Primes)');
+console.log('-'.repeat(40));
+
+const calc = new ResonanceCalculator();
+const primes5 = [2, 3, 5, 7, 11];
+const matrix = calc.calculateMatrix(primes5);
+
+// Header
+console.log('       ' + primes5.map(p => p.toString().padStart(6)).join(' '));
+
+// Rows
+for (let i = 0; i < primes5.length; i++) {
+  const row = matrix[i].map(v => v.toFixed(3).padStart(6)).join(' ');
+  console.log(`  ${primes5[i].toString().padStart(3)}  ${row}`);
+}
+
+// ─────────────────────────────────────────────────────────────────
+// Find Most Resonant
+// ─────────────────────────────────────────────────────────────────
+
+console.log('\n5. Most Resonant Prime');
+console.log('-'.repeat(40));
+
+const target = 5;
+const candidates = [2, 7, 11, 13, 17, 19, 23];
+const most = calc.findMostResonant(target, candidates);
+
+console.log(`  Target: ${target}`);
+console.log(`  Candidates: [${candidates.join(', ')}]`);
+console.log(`  Most resonant: ${most.prime} (resonance: ${most.resonance.toFixed(4)})`);
+
+// ─────────────────────────────────────────────────────────────────
+// Resonance Clusters
+// ─────────────────────────────────────────────────────────────────
+
+console.log('\n6. Resonance Clusters');
+console.log('-'.repeat(40));
+
+const manyPrimes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29];
+const clusters = calc.findClusters(manyPrimes, 0.4);
+
+console.log(`  Primes: [${manyPrimes.join(', ')}]`);
+console.log(`  Threshold: 0.4`);
+console.log(`  Clusters found: ${clusters.length}`);
+for (let i = 0; i < clusters.length; i++) {
+  console.log(`    Cluster ${i + 1}: [${clusters[i].join(', ')}]`);
+}
+
+console.log('\n' + '='.repeat(60));
+console.log('Resonance theory: Primes with ratios near φ have natural harmony');
+console.log('='.repeat(60));

package/examples/06-symbol-database.js

@@ -0,0 +1,150 @@
+/**
+ * Example: Symbol Database
+ * 
+ * Demonstrates the symbolic AI database with 200+ emoji symbols,
+ * their prime assignments, and cultural tagging.
+ */
+
+const {
+  SymbolDatabase,
+  SymbolCategory,
+  symbolDatabase,
+  getSymbol,
+  getSymbolByPrime
+} = require('../core');
+
+console.log('='.repeat(60));
+console.log('Symbolic AI Database');
+console.log('='.repeat(60));
+
+// ─────────────────────────────────────────────────────────────────
+// Database Overview
+// ─────────────────────────────────────────────────────────────────
+
+console.log('\n1. Database Statistics');
+console.log('-'.repeat(40));
+
+const stats = symbolDatabase.getStats();
+console.log(`  Total symbols: ${stats.totalSymbols}`);
+console.log('\n  By category:');
+for (const [category, count] of Object.entries(stats.byCategory)) {
+  console.log(`    ${category}: ${count} symbols`);
+}
+console.log('\n  Top cultural tags:');
+for (const { tag, count } of stats.topTags) {
+  console.log(`    ${tag}: ${count} symbols`);
+}
+
+// ─────────────────────────────────────────────────────────────────
+// Symbol Lookup
+// ─────────────────────────────────────────────────────────────────
+
+console.log('\n2. Symbol Lookup');
+console.log('-'.repeat(40));
+
+const examples = ['hero', 'warrior', 'mountain', 'fire', 'athena', 'samurai'];
+for (const id of examples) {
+  const s = getSymbol(id);
+  if (s) {
+    console.log(`  ${s.unicode} ${s.id} (prime: ${s.prime})`);
+    console.log(`     "${s.meaning}"`);
+    console.log(`     tags: [${s.culturalTags.join(', ')}]`);
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────
+// Reverse Lookup by Prime
+// ─────────────────────────────────────────────────────────────────
+
+console.log('\n3. Reverse Lookup (by Prime)');
+console.log('-'.repeat(40));
+
+const testPrimes = [2, 3, 5, 7, 11, 13];
+for (const p of testPrimes) {
+  const s = getSymbolByPrime(p);
+  if (s) {
+    console.log(`  Prime ${p} → ${s.unicode} ${s.id}`);
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────
+// Category Browsing
+// ─────────────────────────────────────────────────────────────────
+
+console.log('\n4. Browse by Category');
+console.log('-'.repeat(40));
+
+for (const category of Object.values(SymbolCategory)) {
+  const symbols = symbolDatabase.getSymbolsByCategory(category);
+  const sample = symbols.slice(0, 5).map(s => s.unicode).join(' ');
+  console.log(`  ${category}: ${sample}... (${symbols.length} total)`);
+}
+
+// ─────────────────────────────────────────────────────────────────
+// Cultural Filtering
+// ─────────────────────────────────────────────────────────────────
+
+console.log('\n5. Cultural Symbols');
+console.log('-'.repeat(40));
+
+const cultures = ['greek', 'norse', 'japanese', 'egyptian', 'hindu'];
+for (const culture of cultures) {
+  const symbols = symbolDatabase.getSymbolsByTag(culture);
+  if (symbols.length > 0) {
+    const sample = symbols.slice(0, 5).map(s => s.unicode).join(' ');
+    console.log(`  ${culture}: ${sample} (${symbols.length} symbols)`);
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────
+// Search
+// ─────────────────────────────────────────────────────────────────
+
+console.log('\n6. Symbol Search');
+console.log('-'.repeat(40));
+
+const queries = ['warrior', 'wisdom', 'fire'];
+for (const query of queries) {
+  const results = symbolDatabase.search(query);
+  console.log(`  "${query}": ${results.length} results`);
+  for (const r of results.slice(0, 3)) {
+    console.log(`    ${r.unicode} ${r.id}: ${r.meaning.slice(0, 40)}...`);
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────
+// Prime Encoding
+// ─────────────────────────────────────────────────────────────────
+
+console.log('\n7. Prime Encoding');
+console.log('-'.repeat(40));
+
+const concept1 = ['hero', 'journey', 'mountain'];
+const encoded1 = symbolDatabase.encode(concept1);
+console.log(`  Concept: [${concept1.join(', ')}]`);
+console.log(`  Encoded: ${encoded1.toString()}`);
+console.log(`  Decoded: ${symbolDatabase.decode(encoded1).map(s => s.id).join(', ')}`);
+
+const concept2 = ['fire', 'water', 'earth_element'];
+const encoded2 = symbolDatabase.encode(concept2);
+console.log(`\n  Concept: [${concept2.join(', ')}]`);
+console.log(`  Encoded: ${encoded2.toString()}`);
+console.log(`  Decoded: ${symbolDatabase.decode(encoded2).map(s => s.id).join(', ')}`);
+
+// ─────────────────────────────────────────────────────────────────
+// Universal vs Cultural Archetypes
+// ─────────────────────────────────────────────────────────────────
+
+console.log('\n8. Universal Archetypes');
+console.log('-'.repeat(40));
+
+const universal = symbolDatabase.getSymbolsByTag('universal');
+console.log(`  Total universal symbols: ${universal.length}`);
+console.log('  Sample archetypes:');
+for (const s of universal.slice(0, 10)) {
+  console.log(`    ${s.unicode} ${s.id}: ${s.meaning}`);
+}
+
+console.log('\n' + '='.repeat(60));
+console.log('Each symbol has a unique prime - concepts combine via multiplication');
+console.log('='.repeat(60));

package/examples/07-semantic-inference.js

@@ -0,0 +1,223 @@
+/**
+ * Example: Semantic Inference with Resonance Attention
+ *
+ * Demonstrates the semantic inference engine that maps natural language
+ * to symbols through patterns, direct matching, semantic similarity,
+ * AND resonance-based disambiguation using ResoFormer attention.
+ */
+
+const {
+  SemanticInference,
+  EntityExtractor,
+  semanticInference,
+  inferSymbol,
+  inferSymbols,
+  extractEntities,
+  symbolDatabase,
+  inferWithResonance,
+  inferMostResonant,
+  getSymbol
+} = require('../core');
+
+console.log('='.repeat(60));
+console.log('Semantic Inference Engine');
+console.log('='.repeat(60));
+
+// ─────────────────────────────────────────────────────────────────
+// Direct Symbol Inference
+// ─────────────────────────────────────────────────────────────────
+
+console.log('\n1. Direct Symbol Inference');
+console.log('-'.repeat(40));
+
+const directQueries = ['warrior', 'hero', 'fire', 'mountain', 'wisdom'];
+for (const query of directQueries) {
+  const result = inferSymbol(query);
+  if (result) {
+    console.log(`  "${query}" → ${result.symbol.unicode} ${result.symbol.id} [${result.method}]`);
+  } else {
+    console.log(`  "${query}" → (no match)`);
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────
+// Multi-Word Inference
+// ─────────────────────────────────────────────────────────────────
+
+console.log('\n2. Multi-Word Text Inference');
+console.log('-'.repeat(40));
+
+const texts = [
+  'The hero climbs the mountain',
+  'A brave warrior fights in battle',
+  'The sage seeks wisdom in the temple',
+  'Fire and water combine in transformation',
+  'The king rules from his throne'
+];
+
+for (const text of texts) {
+  console.log(`\n  "${text}"`);
+  const symbols = inferSymbols(text);
+  if (symbols.length > 0) {
+    const icons = symbols.map(s => s.symbol.unicode).join(' ');
+    const ids = symbols.map(s => s.symbol.id).join(', ');
+    console.log(`    → ${icons}`);
+    console.log(`    → [${ids}]`);
+  } else {
+    console.log('    → (no symbols matched)');
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────
+// Pattern Matching
+// ─────────────────────────────────────────────────────────────────
+
+console.log('\n3. Pattern-Based Inference');
+console.log('-'.repeat(40));
+
+const patternTests = [
+  'a mighty knight in shining armor',
+  'the old wizard with a long beard',
+  'flames dancing in the night',
+  'deep underground caverns',
+  'stormy seas and crashing waves'
+];
+
+for (const text of patternTests) {
+  const result = inferSymbol(text);
+  if (result) {
+    console.log(`  "${text.slice(0, 30)}..." → ${result.symbol.unicode} ${result.symbol.id} [${result.method}]`);
+  } else {
+    console.log(`  "${text.slice(0, 30)}..." → (no match)`);
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────
+// Entity Extraction
+// ─────────────────────────────────────────────────────────────────
+
+console.log('\n4. Entity Extraction');
+console.log('-'.repeat(40));
+
+const entityTexts = [
+  'John traveled to Paris on Monday',
+  'Dr. Smith discovered the ancient temple in 1985',
+  'The battle occurred at Mount Olympus during summer'
+];
+
+for (const text of entityTexts) {
+  console.log(`\n  "${text}"`);
+  const entities = extractEntities(text);
+  if (entities) {
+    for (const [type, values] of Object.entries(entities)) {
+      if (Array.isArray(values) && values.length > 0) {
+        console.log(`    ${type}: [${values.join(', ')}]`);
+      } else if (typeof values === 'string') {
+        console.log(`    ${type}: ${values}`);
+      }
+    }
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────
+// Symbolic Narrative
+// ─────────────────────────────────────────────────────────────────
+
+console.log('\n5. Symbolic Narrative');
+console.log('-'.repeat(40));
+
+const narrative = `
+The young hero left his village and traveled through the dark forest.
+He crossed the great river and climbed the sacred mountain.
+There he found the ancient sage who revealed the hidden truth.
+Armed with wisdom, he descended to face the shadow within.
+Through fire and transformation, he emerged victorious.
+`;
+
+console.log('  Input narrative:');
+console.log('  ' + narrative.trim().split('\n').map(l => l.trim()).join('\n  '));
+
+const storySymbols = inferSymbols(narrative);
+console.log(`\n  Extracted symbols (${storySymbols.length}):`);
+
+// Group by method
+const byMethod = {};
+for (const s of storySymbols) {
+  if (!byMethod[s.method]) byMethod[s.method] = [];
+  byMethod[s.method].push(s.symbol);
+}
+
+for (const [method, symbols] of Object.entries(byMethod)) {
+  const icons = symbols.map(s => s.unicode).join(' ');
+  console.log(`    ${method}: ${icons}`);
+}
+
+// Calculate resonance of the narrative
+const { resonanceSignature } = require('../core');
+const primes = storySymbols.map(s => s.symbol.prime);
+if (primes.length >= 2) {
+  const sig = resonanceSignature(primes);
+  console.log(`\n  Narrative resonance: mean=${sig.mean.toFixed(4)}, goldenPairs=${sig.goldenCount}`);
+}
+
+// ─────────────────────────────────────────────────────────────────
+// Resonance-Enhanced Inference
+// ─────────────────────────────────────────────────────────────────
+
+console.log('\n6. Resonance-Enhanced Inference (ResoFormer Attention)');
+console.log('-'.repeat(40));
+
+const resonanceText = 'The brave hero fought the shadow in the temple of fire';
+console.log(`  Text: "${resonanceText}"`);
+
+const resonanceResults = inferWithResonance(resonanceText);
+console.log('\n  Symbols ranked by resonance harmony:');
+for (const r of resonanceResults.slice(0, 5)) {
+  const bonus = r.resonanceBonus ? `, resonance: ${r.resonanceBonus.toFixed(3)}` : '';
+  console.log(`    ${r.symbol.unicode} ${r.symbol.id} (confidence: ${r.confidence.toFixed(2)}${bonus})`);
+}
+
+// ─────────────────────────────────────────────────────────────────
+// Context-Aware Symbol Selection
+// ─────────────────────────────────────────────────────────────────
+
+console.log('\n7. Context-Aware Symbol Selection');
+console.log('-'.repeat(40));
+
+const contextSymbols = [getSymbol('warrior'), getSymbol('temple')];
+console.log('  Context:', contextSymbols.map(s => `${s.unicode} ${s.id}`).join(', '));
+
+const testWords = ['sword', 'fire', 'shadow', 'wisdom'];
+console.log('\n  Finding most resonant symbols for context:');
+
+for (const word of testWords) {
+  const best = inferMostResonant(word, contextSymbols);
+  if (best) {
+    const contextR = best.contextResonance ? best.contextResonance.toFixed(4) : 'N/A';
+    console.log(`    "${word}" → ${best.symbol.unicode} ${best.symbol.id} (context resonance: ${contextR})`);
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────
+// Resonance Attention for Disambiguation
+// ─────────────────────────────────────────────────────────────────
+
+console.log('\n8. Resonance Attention for Disambiguation');
+console.log('-'.repeat(40));
+
+console.log('  When multiple symbols could match, resonance picks');
+console.log('  the one that "harmonizes" best with context.\n');
+
+const ambiguousText = 'The warrior king held the sacred ring of power';
+console.log(`  Text: "${ambiguousText}"`);
+
+const disambiguated = inferWithResonance(ambiguousText);
+console.log('\n  Disambiguated symbols (using resonance attention):');
+for (const r of disambiguated) {
+  const weight = r.attentionWeight ? `, attention: ${r.attentionWeight.toFixed(3)}` : '';
+  console.log(`    ${r.symbol.unicode} ${r.symbol.id}${weight}`);
+}
+
+console.log('\n' + '='.repeat(60));
+console.log('Resonance attention: Symbols that harmonize together resonate');
+console.log('='.repeat(60));