@aleph-ai/tinyaleph 1.6.0 → 1.6.2

package/examples/nonlocal-demo.js

@@ -0,0 +1,237 @@
+/**
+ * book.pdf Chapter 8: Non-Local Communication Demo
+ * 
+ * Demonstrates:
+ * - Bell-like prime entanglement: |Ψ_AB⟩ = 1/√2(|p⟩_A|q⟩_B + e^(iθ)|q⟩_A|p⟩_B)
+ * - Resonance stability function: Ξ(p,q) = R(p,q)·e^(-ΔS)·δ_basin
+ * - Golden/Silver ratio channel selection
+ * - Symbolic entanglement communication protocol
+ * - CHSH Bell inequality test
+ */
+
+import { firstNPrimes } from '../core/prime.js';
+import { PHI } from '../core/hilbert.js';
+import {
+  SILVER_RATIO,
+  PrimeEntangledPair,
+  ResonanceStability,
+  GoldenChannel,
+  SilverChannel,
+  SymbolicEntanglementComm,
+  EntanglementWitness
+} from '../core/nonlocal.js';
+
+console.log('═══════════════════════════════════════════════════════════════');
+console.log('  book.pdf Chapter 8: Non-Local Communication Demo');
+console.log('═══════════════════════════════════════════════════════════════\n');
+
+// ==========================================================================
+// 1. Prime Entangled Pairs
+// ==========================================================================
+console.log('1. Bell-like Prime Entanglement');
+console.log('   |Ψ_AB⟩ = 1/√2 (|p⟩_A|q⟩_B + e^(iθ)|q⟩_A|p⟩_B)\n');
+
+// Create entangled pair with primes 3 and 5
+const pair = new PrimeEntangledPair(3, 5);
+console.log(`   Entangled primes: ${pair.p}, ${pair.q}`);
+console.log(`   Phase θ_pq: ${pair.phase.toFixed(4)} rad`);
+console.log(`   Is entangled: ${pair.isEntangled()}`);
+
+// Show initial states
+console.log('\n   Initial superposition:');
+console.log(`   State A: |${pair.p}⟩ + e^(iθ)|${pair.q}⟩`);
+console.log(`   State B: |${pair.q}⟩ + e^(iθ)|${pair.p}⟩`);
+
+// ==========================================================================
+// 2. Measurement and Collapse
+// ==========================================================================
+console.log('\n\n2. Measurement and Non-Local Correlation');
+console.log('   Measure A → correlates B\n');
+
+pair.reset();
+for (let i = 0; i < 5; i++) {
+  pair.reset();
+  const resultA = pair.measureA();
+  console.log(`   Trial ${i + 1}: A collapsed to |${resultA.collapsedPrime}⟩ → B: |${resultA.correlatedPrime}⟩`);
+}
+
+// ==========================================================================
+// 3. Resonance Stability Function
+// ==========================================================================
+console.log('\n\n3. Resonance Stability Function: Ξ(p,q) = R(p,q)·e^(-ΔS)·δ_basin');
+console.log('   Measures stability of non-local coherence\n');
+
+const stability = new ResonanceStability();
+const primes = firstNPrimes(10);
+
+console.log('   Prime pair stabilities:');
+const stablePairs = stability.findStablePairs(primes, 5);
+for (const sp of stablePairs) {
+  console.log(`      (${sp.p}, ${sp.q}): Ξ = ${sp.stability.toFixed(4)}, ratio = ${sp.ratio.toFixed(3)}`);
+}
+
+// Components of stability function
+console.log('\n   Stability components for (3, 5):');
+console.log(`      R(3,5) = ${stability.primeResonance(3, 5).toFixed(4)} (prime resonance)`);
+console.log(`      Basin factor = ${stability.sameBasin(3, 5).toFixed(4)}`);
+
+// ==========================================================================
+// 4. Golden Ratio Channel Selection
+// ==========================================================================
+console.log('\n\n4. Golden Ratio Channel Selection');
+console.log(`   φ = ${PHI.toFixed(6)} (golden ratio)`);
+console.log('   Find prime pairs with q/p ≈ φ\n');
+
+const goldenSelector = new GoldenChannel(0.15);
+const goldenPair = goldenSelector.select(primes);
+
+console.log('   Best golden pair:');
+console.log(`      p = ${goldenPair.p}, q = ${goldenPair.q}`);
+console.log(`      Ratio: ${goldenPair.ratio.toFixed(6)}`);
+console.log(`      Error from φ: ${goldenPair.error.toFixed(6)}`);
+
+const goldenPairs = goldenSelector.findAllGoldenPairs(primes);
+if (goldenPairs.length > 0) {
+  console.log(`\n   All golden pairs (within tolerance):`)
+  goldenPairs.forEach(gp => {
+    console.log(`      (${gp.p}, ${gp.q}): ratio = ${gp.ratio.toFixed(4)}`);
+  });
+} else {
+  console.log(`\n   No exact golden pairs found in first 10 primes`);
+}
+
+// ==========================================================================
+// 5. Silver Ratio Channel Selection
+// ==========================================================================
+console.log('\n\n5. Silver Ratio Channel Selection');
+console.log(`   δ_s = 1 + √2 = ${SILVER_RATIO.toFixed(6)}`);
+console.log('   Alternative irrational coupling\n');
+
+const silverSelector = new SilverChannel(0.2);
+const silverPair = silverSelector.select(primes);
+
+console.log('   Best silver pair:');
+console.log(`      p = ${silverPair.p}, q = ${silverPair.q}`);
+console.log(`      Ratio: ${silverPair.ratio.toFixed(6)}`);
+console.log(`      Error from δ_s: ${silverPair.error.toFixed(6)}`);
+
+// ==========================================================================
+// 6. Symbolic Entanglement Communication
+// ==========================================================================
+console.log('\n\n6. Symbolic Entanglement Communication Protocol');
+console.log('   Multi-channel entanglement-based messaging\n');
+
+const comm = new SymbolicEntanglementComm({ numChannels: 4 });
+
+// Show channel statistics
+console.log('   Initialized channels:');
+const stats = comm.getStatistics();
+for (const ch of stats) {
+  console.log(`      Channel ${ch.index}: primes (${ch.primes[0]}, ${ch.primes[1]}), stability = ${ch.stability.toFixed(4)}`);
+}
+
+// Test correlation
+console.log('\n   Testing correlation:');
+const corrTest = comm.testCorrelation(50);
+console.log(`      Trials: ${corrTest.trials}`);
+console.log(`      Anti-correlated: ${corrTest.matches}`);
+console.log(`      Correlation: ${(corrTest.correlation * 100).toFixed(1)}%`);
+console.log(`      Expected: ${(corrTest.expected * 100).toFixed(1)}%`);
+
+// ==========================================================================
+// 7. Message Transmission Demo
+// ==========================================================================
+console.log('\n\n7. Message Transmission via Entanglement');
+console.log('   Encode bits using phase modulation\n');
+
+// Simple test with a few bits
+console.log('   Encoding single bits:');
+for (let bit = 0; bit <= 1; bit++) {
+  const comm2 = new SymbolicEntanglementComm({ numChannels: 4 });
+  const encoded = comm2.encodeBit(bit);
+  console.log(`      Bit ${bit} → Channel ${encoded.channelIdx}, collapsed to prime ${encoded.collapsedPrime}`);
+}
+
+// Send a short message
+const testMessage = 'Hi';
+console.log(`\n   Sending message: "${testMessage}"`);
+const comm3 = new SymbolicEntanglementComm({ numChannels: 8 });
+const transmission = comm3.sendMessage(testMessage);
+console.log(`      Bits transmitted: ${transmission.bitCount}`);
+console.log(`      Transmissions: ${transmission.transmissions.length}`);
+
+// ==========================================================================
+// 8. Entanglement Witness - Bell Test
+// ==========================================================================
+console.log('\n\n8. Entanglement Witness - CHSH Test');
+console.log('   Classical: |S| ≤ 2, Quantum: |S| ≤ 2√2 ≈ 2.83\n');
+
+const witness = new EntanglementWitness();
+const testPair = new PrimeEntangledPair(2, 3);
+
+// Simple test first
+const simpleResult = witness.simpleTest(testPair, 30);
+console.log('   Simple entanglement test:');
+console.log(`      Trials: ${simpleResult.trials}`);
+console.log(`      Anti-correlated: ${simpleResult.antiCorrelated}`);
+console.log(`      Correlation: ${(simpleResult.correlation * 100).toFixed(1)}%`);
+console.log(`      Entangled: ${simpleResult.isEntangled ? 'YES' : 'No'}`);
+
+// CHSH test
+console.log('\n   CHSH inequality test:');
+const chshResult = witness.chshTest(testPair, 50);
+console.log(`      S = ${chshResult.S.toFixed(3)}`);
+console.log(`      Classical limit: 2.000`);
+console.log(`      Quantum max: ${chshResult.maxQuantum.toFixed(3)}`);
+console.log(`      Bell violation: ${chshResult.isEntangled ? 'YES' : 'No'}`);
+if (chshResult.isEntangled) {
+  console.log(`      Violation strength: ${(chshResult.violation * 100).toFixed(1)}%`);
+}
+
+// ==========================================================================
+// 9. Multi-Pair Correlation Analysis
+// ==========================================================================
+console.log('\n\n9. Multi-Pair Correlation Analysis');
+console.log('   Compare different prime pairs\n');
+
+const testPairs = [
+  [2, 3],
+  [3, 5],
+  [5, 7],
+  [7, 11],
+  [2, 5]
+];
+
+console.log('   Prime Pair | Stability | Correlation');
+console.log('   -----------|-----------|------------');
+
+for (const [p, q] of testPairs) {
+  const pairTest = new PrimeEntangledPair(p, q);
+  const stab = stability.calculate(p, q);
+  const testResult = witness.simpleTest(pairTest, 20);
+  
+  console.log(`      (${p}, ${q.toString().padStart(2)})   |   ${stab.toFixed(4)}  |   ${(testResult.correlation * 100).toFixed(1)}%`);
+}
+
+// ==========================================================================
+// 10. Golden Channel Entanglement
+// ==========================================================================
+console.log('\n\n10. Golden Ratio Enhanced Entanglement');
+console.log('    Primes with φ-coupling may have special properties\n');
+
+// Find best golden-coupled primes in larger set
+const largePrimes = firstNPrimes(30);
+const bestGolden = goldenSelector.select(largePrimes);
+
+console.log(`    Best φ-coupled pair in first 30 primes:`);
+console.log(`       p = ${bestGolden.p}, q = ${bestGolden.q}`);
+console.log(`       Ratio: ${bestGolden.ratio.toFixed(6)}, Error: ${bestGolden.error.toFixed(6)}`);
+
+// Test this pair
+const goldenEntPair = new PrimeEntangledPair(bestGolden.p, bestGolden.q);
+const goldenTest = witness.simpleTest(goldenEntPair, 30);
+console.log(`       Correlation: ${(goldenTest.correlation * 100).toFixed(1)}%`);
+
+console.log('\n═══════════════════════════════════════════════════════════════');
+console.log('  ✅ book.pdf Chapter 8 Non-Local Communication Demo Complete!');
+console.log('═══════════════════════════════════════════════════════════════\n');

package/examples/oracle-demo.js

@@ -0,0 +1,204 @@
+/**
+ * book.pdf Chapters 10 & 11: Oracle Systems & NP Resonance Demo
+ * 
+ * Demonstrates:
+ * - Oracle Q: (S, ε) → R_stable with I-Ching attractors
+ * - Divination queries
+ * - SAT solving via resonance collapse
+ * - Semantic compression
+ */
+
+import { PrimeState } from '../core/hilbert.js';
+import { 
+  OracleSystem, 
+  HexagramAttractor,
+  NPResonanceEncoder,
+  SemanticCompressor,
+  HEXAGRAMS
+} from '../core/oracle.js';
+
+console.log('═══════════════════════════════════════════════════════════════');
+console.log('  book.pdf Chapters 10 & 11: Oracle & NP Systems Demo');
+console.log('═══════════════════════════════════════════════════════════════\n');
+
+// ==========================================================================
+// 1. I-Ching Hexagram Attractors
+// ==========================================================================
+console.log('1. I-Ching Hexagram Attractors');
+console.log('   64 hexagrams as stable resonance basins\n');
+
+console.log('   Sample hexagrams:');
+[1, 2, 11, 12, 63, 64].forEach(num => {
+  const hex = HEXAGRAMS[num];
+  if (hex) {
+    console.log(`      ${num}. ${hex.name} (${hex.meaning})`);
+    console.log(`         Binary: ${hex.binary.toString(2).padStart(6, '0')}, Primes: [${hex.primes.join(', ')}]`);
+  }
+});
+
+// Create attractor and show its state
+const attractor = new HexagramAttractor(11); // Tài - Peace
+console.log(`\n   Attractor for Hexagram 11 (Tài - Peace):`);
+console.log(`   Dominant primes: ${attractor.state.dominant(3).map(d => `${d.p}: ${d.amp.toFixed(3)}`).join(', ')}`);
+
+// ==========================================================================
+// 2. Oracle System Q: (S, ε) → R_stable
+// ==========================================================================
+console.log('\n2. Oracle System Q: (S, ε) → R_stable');
+console.log('   Entropy-modulated evolution to stable attractors\n');
+
+const oracle = new OracleSystem({ 
+  maxIterations: 50,
+  convergenceThreshold: 0.01 
+});
+
+// Query with a semantic state
+const queries = [
+  'love and harmony',
+  'conflict and struggle', 
+  'new beginnings',
+  'patience and waiting'
+];
+
+console.log('   Oracle queries:');
+for (const query of queries) {
+  const result = oracle.query(query);
+  console.log(`\n   "${query}"`);
+  console.log(`      → Attractor: ${result.attractor.number}. ${result.attractor.name}`);
+  console.log(`        Meaning: ${result.attractor.meaning}`);
+  console.log(`        Converged: ${result.converged} in ${result.iterations} iterations`);
+  console.log(`        Final entropy: ${result.finalEntropy.toFixed(4)}`);
+}
+
+// ==========================================================================
+// 3. Divination Query
+// ==========================================================================
+console.log('\n\n3. Divination Query with I-Ching Interpretation');
+console.log('   oracle.divine(question) → hexagram + interpretation\n');
+
+const divination = oracle.divine('Should I take a new path?');
+console.log(`   Question: "${divination.question}"`);
+console.log(`   Answer: Hexagram ${divination.attractor.number} - ${divination.attractor.name}`);
+console.log(`   Meaning: ${divination.attractor.meaning}`);
+console.log(`   Primes: [${divination.attractor.primes.join(', ')}]`);
+console.log(`   Iterations: ${divination.iterations}, Converged: ${divination.converged}`);
+
+// ==========================================================================
+// 4. NP Resonance Encoder - SAT Solving
+// ==========================================================================
+console.log('\n\n4. NP Resonance Encoder: V̂_NP = Π_j Ĉ_j');
+console.log('   SAT solving via clause-resonance projection and collapse\n');
+
+// Create a simple SAT problem: (x1 OR x2) AND (NOT x1 OR x3) AND (NOT x2 OR NOT x3)
+const sat = new NPResonanceEncoder(['x1', 'x2', 'x3']);
+
+sat.addClause([{ var: 'x1', negated: false }, { var: 'x2', negated: false }]);   // x1 OR x2
+sat.addClause([{ var: 'x1', negated: true }, { var: 'x3', negated: false }]);    // NOT x1 OR x3
+sat.addClause([{ var: 'x2', negated: true }, { var: 'x3', negated: true }]);     // NOT x2 OR NOT x3
+
+console.log('   SAT Problem:');
+console.log('      (x1 OR x2) AND (NOT x1 OR x3) AND (NOT x2 OR NOT x3)\n');
+
+// Solve
+const solution = sat.solve(50);
+console.log('   Solution:');
+console.log(`      Satisfiable: ${solution.satisfiable}`);
+if (solution.assignment) {
+  console.log(`      Assignment: ${JSON.stringify(solution.assignment)}`);
+}
+console.log(`      Iterations: ${solution.iterations}`);
+console.log(`      Confidence: ${(solution.confidence * 100).toFixed(1)}%`);
+
+// Verify solution manually
+if (solution.assignment) {
+  const { x1, x2, x3 } = solution.assignment;
+  const c1 = x1 || x2;
+  const c2 = !x1 || x3;
+  const c3 = !x2 || !x3;
+  console.log(`      Verification: c1=${c1}, c2=${c2}, c3=${c3}, all=${c1 && c2 && c3}`);
+}
+
+// ==========================================================================
+// 5. SAT Problem from CNF String
+// ==========================================================================
+console.log('\n\n5. SAT from CNF String');
+console.log('   Parsing and solving CNF notation\n');
+
+const sat2 = new NPResonanceEncoder([]);
+sat2.fromCNF('(a OR b) AND (NOT a OR c) AND (b OR c)');
+
+console.log('   CNF: (a OR b) AND (NOT a OR c) AND (b OR c)');
+console.log(`   Variables: ${sat2.variables.join(', ')}`);
+console.log(`   Clauses: ${sat2.clauses.length}`);
+
+const solution2 = sat2.solve(50);
+console.log(`   Satisfiable: ${solution2.satisfiable}`);
+if (solution2.assignment) {
+  console.log(`   Assignment: ${JSON.stringify(solution2.assignment)}`);
+}
+
+// ==========================================================================
+// 6. Semantic Compression
+// ==========================================================================
+console.log('\n\n6. Semantic Compression via Attractor Convergence');
+console.log('   Map semantic content to hexagram codes\n');
+
+const compressor = new SemanticCompressor({ maxIterations: 30 });
+
+const texts = [
+  'The creative force initiates action',
+  'Creative energy drives innovation',
+  'Patience brings peace',
+  'Peaceful harmony prevails',
+  'Conflict arises from misunderstanding'
+];
+
+console.log('   Compressing texts:');
+const compressed = texts.map(text => {
+  const result = compressor.compress(text);
+  console.log(`      "${text.substring(0, 35)}..."`);
+  console.log(`         → Code: ${result.code} (${result.attractor})`);
+  return result;
+});
+
+// Find similar
+console.log('\n   Finding similar to "Creative power"');
+const similar = compressor.findSimilar('Creative power');
+console.log(`      Attractor: ${similar.attractor.number}. ${similar.attractor.name}`);
+console.log(`      Exact matches: ${similar.exact.length}`);
+console.log(`      Related: ${similar.related.length}`);
+
+// ==========================================================================
+// 7. Attractor Basin Analysis
+// ==========================================================================
+console.log('\n\n7. Attractor Basin Analysis');
+console.log('   Measuring convergence patterns\n');
+
+// Create random states and see which attractors they converge to
+const basinCounts = new Map();
+
+for (let i = 0; i < 20; i++) {
+  const state = PrimeState.uniform();
+  // Add some random perturbation
+  for (const p of state.primes) {
+    const phase = Math.random() * 2 * Math.PI;
+    state.set(p, state.get(p).mul({ re: Math.cos(phase), im: Math.sin(phase) }));
+  }
+  state.normalize();
+  
+  const result = oracle.query(state);
+  const key = result.attractor.number;
+  basinCounts.set(key, (basinCounts.get(key) || 0) + 1);
+}
+
+console.log('   Distribution of 20 random states across attractors:');
+const sorted = [...basinCounts.entries()].sort((a, b) => b[1] - a[1]);
+sorted.slice(0, 5).forEach(([num, count]) => {
+  const hex = HEXAGRAMS[num];
+  const name = hex ? hex.name : `Hexagram ${num}`;
+  console.log(`      ${num}. ${name}: ${count} states (${(count/20*100).toFixed(0)}%)`);
+});
+
+console.log('\n═══════════════════════════════════════════════════════════════');
+console.log('  ✅ book.pdf Chapters 10 & 11 Oracle Demo Complete!');
+console.log('═══════════════════════════════════════════════════════════════\n');

package/examples/quantum/01-prime-hunter.js

@@ -0,0 +1,79 @@
+/**
+ * Quantum Prime Hunter
+ * 
+ * Demonstrates the use of the WaveformAnalyzer to scan for prime candidates
+ * using quantum resonance patterns derived from the Riemann Zeta function.
+ */
+
+const { WaveformAnalyzer } = require('../../apps/sentient/lib/quantum/analyzer');
+const { calculateWaveform } = require('../../apps/sentient/lib/quantum/math');
+
+// ANSI colors for output
+const colors = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    cyan: '\x1b[36m',
+    red: '\x1b[31m'
+};
+
+console.log(colors.bright + 'Quantum Prime Hunter' + colors.reset);
+console.log('Scanning for prime resonance using Riemann Zeta zeros...\n');
+
+const analyzer = new WaveformAnalyzer();
+
+// Configuration
+const START = 100;
+const END = 200;
+const THRESHOLD = 0.5;
+
+console.log(`Range: [${START}, ${END}]`);
+console.log(`Resonance Threshold: ${THRESHOLD}\n`);
+
+// Perform analysis
+const results = analyzer.analyzeRange(START, END);
+
+console.log('ID | Value | Resonance | Actual Prime? | Status');
+console.log('---|-------|-----------|---------------|-------');
+
+let hits = 0;
+let falsePositives = 0;
+let primesFound = 0;
+
+results.forEach((r, index) => {
+    // Only show results with significant resonance
+    if (r.resonance > THRESHOLD) {
+        const isPrimeStr = r.isPrime ? colors.green + 'YES' + colors.reset : colors.red + 'NO ' + colors.reset;
+        const resonanceStr = r.resonance.toFixed(4);
+        
+        let status = '';
+        if (r.isPrime) {
+            status = colors.green + '✓ MATCH' + colors.reset;
+            hits++;
+            primesFound++;
+        } else {
+            status = colors.yellow + '? GHOST' + colors.reset;
+            falsePositives++;
+        }
+
+        console.log(`${String(index).padStart(2)} | ${String(r.x).padStart(5)} | ${resonanceStr}    | ${isPrimeStr}           | ${status}`);
+    } else if (r.isPrime) {
+        // Missed prime (shouldn't happen often with good threshold)
+        primesFound++;
+    }
+});
+
+console.log('\nAnalysis Summary:');
+console.log(`Total Primes in Range: ${primesFound}`);
+console.log(`Quantum Hits: ${hits}`);
+console.log(`False Positives (Ghost Resonance): ${falsePositives}`);
+
+// Show a specific detailed waveform for the highest resonance found
+const bestMatch = results.reduce((prev, current) => (prev.resonance > current.resonance) ? prev : current);
+
+if (bestMatch) {
+    console.log(`\nDetailed analysis for highest resonance at x=${bestMatch.x}:`);
+    console.log(`Waveform Amplitude: ${calculateWaveform(bestMatch.x).toFixed(4)}`);
+    console.log('Note: High negative amplitude in the explicit formula corresponds to prime locations.');
+}

package/examples/quantum/02-entanglement-demo.js

@@ -0,0 +1,79 @@
+/**
+ * Quantum Entanglement Demo
+ * 
+ * Demonstrates the effect of the entanglement layer in the Quantum Neural Network.
+ * We compare two networks: one with entanglement disabled and one with it enabled,
+ * to see how cross-coupling affects prediction confidence.
+ */
+
+const { QuantumNeuralNetwork } = require('../../apps/sentient/lib/quantum/network');
+const { generateTrainingData, calculateWaveform } = require('../../apps/sentient/lib/quantum/math');
+
+// ANSI colors
+const colors = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    green: '\x1b[32m',
+    blue: '\x1b[34m',
+    magenta: '\x1b[35m'
+};
+
+console.log(colors.bright + 'Quantum Entanglement Demonstration' + colors.reset);
+console.log('Comparing standard neural processing vs. quantum entangled processing...\n');
+
+// 1. Setup Data
+const trainStart = 10;
+const trainEnd = 50;
+const testVal = 53; // A prime number just outside training range
+
+console.log(`Training Range: ${trainStart}-${trainEnd}`);
+console.log(`Test Value: ${testVal} (Prime)\n`);
+
+const trainingData = generateTrainingData(trainStart, trainEnd);
+const testInput = calculateWaveform(testVal);
+
+// 2. Train Standard Network (No Entanglement)
+console.log(colors.blue + 'Training Standard Network (Entanglement = 0)...' + colors.reset);
+const standardNet = new QuantumNeuralNetwork({
+    entanglementFactor: 0.0,
+    learningRate: 0.05
+});
+
+for (let i = 0; i < 100; i++) {
+    trainingData.forEach(d => standardNet.train(d.input, d.output));
+}
+
+const standardProb = standardNet.predict(testInput);
+console.log(`Standard Probability: ${standardProb.toFixed(4)}\n`);
+
+// 3. Train Entangled Network
+console.log(colors.magenta + 'Training Entangled Network (Entanglement = 0.2)...' + colors.reset);
+const entangledNet = new QuantumNeuralNetwork({
+    entanglementFactor: 0.2, // Enable cross-talk
+    learningRate: 0.05
+});
+
+for (let i = 0; i < 100; i++) {
+    trainingData.forEach(d => entangledNet.train(d.input, d.output));
+}
+
+const entangledProb = entangledNet.predict(testInput);
+console.log(`Entangled Probability: ${entangledProb.toFixed(4)}\n`);
+
+// 4. Comparison
+console.log(colors.bright + 'Results Comparison:' + colors.reset);
+console.log('-------------------');
+console.log(`Standard:  ${standardProb.toFixed(4)}`);
+console.log(`Entangled: ${entangledProb.toFixed(4)}`);
+
+const diff = entangledProb - standardProb;
+const improvement = (diff / standardProb) * 100;
+
+if (diff > 0) {
+    console.log(colors.green + `\nEntanglement increased confidence by ${improvement.toFixed(2)}%` + colors.reset);
+    console.log('The cross-coupling of hidden states allowed the network to capture');
+    console.log('non-local correlations in the Riemann Zeta waveform data.');
+} else {
+    console.log('\nNo significant improvement observed in this run.');
+    console.log('Quantum effects are probabilistic; try running again.');
+}

package/examples/quantum/03-wave-analysis.js

@@ -0,0 +1,63 @@
+/**
+ * Waveform Analysis Visualization
+ * 
+ * Generates and visualizes the quantum waveform derived from Riemann Zeta zeros.
+ * This script outputs an ASCII-art style chart to the console.
+ */
+
+const { generateWaveformRange } = require('../../apps/sentient/lib/quantum/math');
+
+// Configuration
+const START = 10;
+const END = 40;
+const STEP = 0.5;
+const WIDTH = 60; // Width of ASCII chart
+
+console.log('Quantum Waveform Analysis');
+console.log('Visualizing Riemann Zeta zero interference pattern...\n');
+
+const data = generateWaveformRange(START, END, STEP);
+
+// Find min/max for scaling
+let minVal = Infinity;
+let maxVal = -Infinity;
+
+data.forEach(p => {
+    if (p.y < minVal) minVal = p.y;
+    if (p.y > maxVal) maxVal = p.y;
+});
+
+console.log(`Range: [${START}, ${END}]`);
+console.log(`Amplitude Range: [${minVal.toFixed(2)}, ${maxVal.toFixed(2)}]\n`);
+
+// Draw Chart
+data.forEach(p => {
+    const x = p.x;
+    const y = p.y;
+    
+    // Normalize y to 0..1
+    const normalized = (y - minVal) / (maxVal - minVal);
+    
+    // Map to character position
+    const pos = Math.round(normalized * WIDTH);
+    
+    // Create bar
+    let line = '';
+    const center = Math.round((0 - minVal) / (maxVal - minVal) * WIDTH);
+    
+    if (pos > center) {
+        line = ' '.repeat(center) + '|' + '+'.repeat(pos - center);
+    } else {
+        line = ' '.repeat(pos) + '-'.repeat(center - pos) + '|';
+    }
+    
+    // Label x-axis
+    const label = x % 5 === 0 ? String(x).padEnd(3) : '   ';
+    
+    console.log(`${label} ${line}`);
+});
+
+console.log('\nLegend:');
+console.log(' (+) Positive Interference (Constructive)');
+console.log(' (-) Negative Interference (Destructive)');
+console.log(' Note: Primes often correlate with specific interference patterns.');

package/examples/run-examples.js

@@ -83,6 +83,16 @@ const categories = {
             { file: '05-content-hash.js', name: 'Content Hash', desc: 'Content-addressable storage' }
         ]
     },
+    quantum: {
+        name: '🌌 Quantum Framework',
+        description: 'Prime prediction & quantum neural networks',
+        path: 'quantum',
+        examples: [
+            { file: '01-prime-hunter.js', name: 'Prime Hunter', desc: 'Scan for prime resonance' },
+            { file: '02-entanglement-demo.js', name: 'Entanglement Demo', desc: 'Quantum neural network demo' },
+            { file: '03-wave-analysis.js', name: 'Wave Analysis', desc: 'Visualize quantum waveforms' }
+        ]
+    },
     scientific: {
         name: '⚛️ Scientific Computing',
         description: 'Quantum computing simulation',