@aleph-ai/tinyaleph 1.5.7 → 1.6.0

package/examples/bioinformatics/05-molecular-binding.js

@@ -0,0 +1,209 @@
+/**
+ * @example Molecular Binding
+ * @description Analyze molecular binding affinity using spectral coherence
+ * 
+ * This example demonstrates how TinyAleph calculates binding affinity
+ * between molecules using spectral coherence of their hypercomplex states.
+ * Higher coherence = stronger binding affinity.
+ */
+
+const { BioinformaticsBackend } = require('../../modular');
+
+// Import encoding functions directly for protein encoding
+const encoding = require('../../backends/bioinformatics/encoding');
+
+// ===========================================
+// SETUP
+// ===========================================
+
+const backend = new BioinformaticsBackend();
+
+// ===========================================
+// SEQUENCE SIMILARITY
+// ===========================================
+
+console.log('TinyAleph Molecular Binding Example');
+console.log('====================================\n');
+
+console.log('SEQUENCE SIMILARITY ANALYSIS');
+console.log('----------------------------\n');
+
+// Compare similar and different sequences
+const sequences = [
+    { name: 'Seq A', seq: 'ATGCATGC' },
+    { name: 'Seq B', seq: 'ATGCATGC' },  // Identical to A
+    { name: 'Seq C', seq: 'ATGGATGC' },  // One mutation from A
+    { name: 'Seq D', seq: 'TACGTACG' },  // Complement of A
+    { name: 'Seq E', seq: 'GGGGCCCC' },  // Completely different
+];
+
+// Encode all sequences
+const states = sequences.map(s => ({
+    ...s,
+    primes: backend.encode(s.seq),
+    state: backend.primesToState(backend.encode(s.seq))
+}));
+
+console.log('Sequences:');
+sequences.forEach(s => console.log(`  ${s.name}: ${s.seq}`));
+
+console.log('\nSimilarity Matrix (based on sequence similarity):');
+console.log('         ' + sequences.map(s => s.name.padEnd(7)).join(''));
+console.log('         ' + sequences.map(() => '-------').join(''));
+
+for (let i = 0; i < states.length; i++) {
+    let row = states[i].name + ': ';
+    for (let j = 0; j < states.length; j++) {
+        const sim = backend.similarity(states[i].primes, states[j].primes);
+        row += (typeof sim === 'number' ? Math.abs(sim).toFixed(3) : 'N/A').padEnd(8);
+    }
+    console.log(row);
+}
+
+// ===========================================
+// PROTEIN-DNA BINDING
+// ===========================================
+
+console.log('\n\nPROTEIN-DNA BINDING AFFINITY');
+console.log('----------------------------\n');
+
+// Define a DNA binding site and different proteins
+const dnaBindingSite = 'ATGCATGC';
+
+// Proteins with different binding preferences (simplified)
+const proteins = [
+    { name: 'Protein 1', seq: 'MHLA' },   // Hypothetical DNA-binding protein
+    { name: 'Protein 2', seq: 'WFIV' },   // Hydrophobic - unlikely to bind DNA
+    { name: 'Protein 3', seq: 'KRKR' },   // Positively charged - binds DNA backbone
+];
+
+console.log('DNA Binding Site:', dnaBindingSite);
+console.log('\nProtein Binding Affinities:');
+
+const dnaPrimes = backend.encode(dnaBindingSite);
+
+for (const protein of proteins) {
+    // Encode protein using the encoding module
+    const proteinPrimes = encoding.encodeProtein(protein.seq);
+    const result = backend.bindingAffinity(dnaPrimes, proteinPrimes);
+    const affinity = result.affinity || result;
+    
+    // Classify affinity
+    let classification;
+    const absAffinity = Math.abs(affinity);
+    if (absAffinity > 0.5) classification = 'Strong';
+    else if (absAffinity > 0.2) classification = 'Moderate';
+    else classification = 'Weak';
+    
+    console.log(`\n  ${protein.name} (${protein.seq}):`);
+    console.log(`    Affinity score: ${(typeof affinity === 'number' ? affinity : 0).toFixed(4)}`);
+    console.log(`    Classification: ${classification}`);
+    if (result.goldenPairs) {
+        console.log(`    Golden pairs: ${result.goldenPairs}`);
+    }
+}
+
+// ===========================================
+// COMPLEMENTARY STRAND BINDING
+// ===========================================
+
+console.log('\n\nCOMPLEMENTARY STRAND BINDING');
+console.log('-----------------------------\n');
+
+const strand1 = 'ATGCATGC';
+const COMPLEMENT = { 'A': 'T', 'T': 'A', 'G': 'C', 'C': 'G' };
+const complement = strand1.split('').map(b => COMPLEMENT[b]).join('');
+const mismatch = 'TACGAAAA';  // Partial mismatch
+
+console.log('Template strand:    ', strand1);
+console.log('True complement:    ', complement);
+console.log('Mismatched strand:  ', mismatch);
+
+const templatePrimes = backend.encode(strand1);
+const complementPrimes = backend.encode(complement);
+const mismatchPrimes = backend.encode(mismatch);
+
+const perfectResult = backend.bindingAffinity(templatePrimes, complementPrimes);
+const imperfectResult = backend.bindingAffinity(templatePrimes, mismatchPrimes);
+
+const perfectBinding = perfectResult.affinity || perfectResult;
+const imperfectBinding = imperfectResult.affinity || imperfectResult;
+
+console.log('\nBinding affinities:');
+console.log(`  Perfect complement: ${(typeof perfectBinding === 'number' ? perfectBinding : 0).toFixed(4)}`);
+console.log(`  Mismatched strand:  ${(typeof imperfectBinding === 'number' ? imperfectBinding : 0).toFixed(4)}`);
+
+// ===========================================
+// DRUG-TARGET INTERACTION (CONCEPTUAL)
+// ===========================================
+
+console.log('\n\nDRUG-TARGET INTERACTION MODEL');
+console.log('------------------------------\n');
+
+// Model a drug molecule as a short peptide
+const targetProtein = 'MWLKFVIER';
+const drugs = [
+    { name: 'Drug A', seq: 'FW' },   // Aromatic - may bind hydrophobic pocket
+    { name: 'Drug B', seq: 'KR' },   // Charged - binds surface
+    { name: 'Drug C', seq: 'LI' },   // Hydrophobic - binds core
+];
+
+console.log('Target protein:', targetProtein);
+console.log('\nDrug screening results:');
+
+const targetPrimes = encoding.encodeProtein(targetProtein);
+
+for (const drug of drugs) {
+    const drugPrimes = encoding.encodeProtein(drug.seq);
+    const result = backend.bindingAffinity(targetPrimes, drugPrimes);
+    const score = result.affinity || result;
+    
+    let verdict;
+    const absScore = Math.abs(typeof score === 'number' ? score : 0);
+    if (absScore > 0.4) verdict = '★★★ Lead candidate';
+    else if (absScore > 0.2) verdict = '★★  Further study';
+    else verdict = '★   Low priority';
+    
+    console.log(`\n  ${drug.name} (${drug.seq}):`);
+    console.log(`    Binding score: ${(typeof score === 'number' ? score : 0).toFixed(4)}`);
+    console.log(`    Verdict: ${verdict}`);
+    if (result.interactions) {
+        console.log(`    Interactions: ${result.interactions.length}`);
+    }
+}
+
+// ===========================================
+// BINDING MECHANICS
+// ===========================================
+
+console.log('\n\nBINDING MECHANICS (Prime Resonance)');
+console.log('------------------------------------\n');
+
+console.log('How binding affinity is calculated:');
+console.log('');
+console.log('  1. Each molecule encoded as hypercomplex state');
+console.log('     - Nucleotides/amino acids → prime numbers');
+console.log('     - Primes → oscillator frequencies');
+console.log('     - Frequencies → sedenion components');
+console.log('');
+console.log('  2. Binding affinity = spectral coherence');
+console.log('     - Inner product of normalized states');
+console.log('     - Higher coherence = more resonance');
+console.log('     - Resonance implies favorable interaction');
+console.log('');
+console.log('  3. Physical interpretation:');
+console.log('     - Shape complementarity → frequency matching');
+console.log('     - Electrostatic fit → prime product harmony');
+console.log('     - Hydrophobic matching → low-frequency resonance');
+
+// ===========================================
+// KEY TAKEAWAYS
+// ===========================================
+
+console.log('\n====================================');
+console.log('KEY TAKEAWAYS:');
+console.log('1. Binding affinity modeled as spectral coherence');
+console.log('2. Complementary sequences show high coherence');
+console.log('3. Can screen for protein-DNA and drug-target interactions');
+console.log('4. Prime resonance captures molecular compatibility');
+console.log('5. Simple model captures key binding principles');

package/examples/chat.js

@@ -0,0 +1,105 @@
+/**
+ * Aleph Chat Client
+ * Command-line interface to converse with Aleph
+ * 
+ * Updated to use modular architecture.
+ */
+const readline = require('readline');
+const fs = require('fs');
+const path = require('path');
+const { createEngine, SemanticBackend } = require('../modular');
+
+// Configuration
+const semanticConfig = {
+  dimension: 16,
+  vocabulary: require('../data.json').vocabulary,
+  ontology: require('../data.json').ontology || {},
+  transforms: require('../data.json').transforms || []
+};
+
+const engine = createEngine('semantic', semanticConfig);
+
+// Watch for changes in data.json
+const DATA_FILE = path.join(__dirname, '../data.json');
+fs.watchFile(DATA_FILE, (curr, prev) => {
+  if (curr.mtime !== prev.mtime) {
+    console.log('\n[System] data.json changed. Reloading...');
+    try {
+      delete require.cache[require.resolve('../data.json')];
+      const newData = require('../data.json');
+      
+      // Create new backend with updated vocabulary
+      const newBackend = new SemanticBackend({
+        dimension: 16,
+        vocabulary: newData.vocabulary,
+        ontology: newData.ontology || {},
+        transforms: newData.transforms || []
+      });
+      engine.setBackend(newBackend);
+      
+      console.log(`[System] Reloaded. Vocabulary size: ${Object.keys(newData.vocabulary).length}`);
+      rl.prompt();
+    } catch (e) {
+      console.error(`[System] Failed to reload: ${e.message}`);
+    }
+  }
+});
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+  prompt: 'Aleph> '
+});
+
+console.log('🔮 Aleph Chat v2.0 (Modular Architecture)');
+console.log('Type "exit" to quit, "info" for system stats.');
+console.log('-------------------------------------------');
+
+rl.prompt();
+
+rl.on('line', async (line) => {
+  const input = line.trim();
+  
+  if (!input) {
+    rl.prompt();
+    return;
+  }
+
+  if (input === 'exit') {
+    console.log('Goodbye.');
+    process.exit(0);
+  }
+
+  if (input === 'info') {
+    const state = engine.getPhysicsState();
+    const info = engine.getBackendInfo();
+    console.log(`H=${state.entropy.toFixed(3)} C=${state.coherence.toFixed(3)} λ=${state.lyapunov.toFixed(3)}`);
+    console.log(`Backend: ${info.name} | Dim: ${info.dimension} | Order: ${state.orderParameter.toFixed(3)}`);
+    rl.prompt();
+    return;
+  }
+
+  try {
+    // Process input through engine
+    const r = engine.run(input);
+    displayResponse(r);
+  } catch (e) {
+    console.error('Error:', e.message);
+  }
+
+  rl.prompt();
+});
+
+function displayResponse(r) {
+  // Show internal state
+  const primes = r.inputPrimes.slice(0, 5).join(',');
+  console.log(`  [${primes}...]`);
+  console.log(`  H=${r.entropy.toFixed(2)} C=${r.coherence.toFixed(2)} ${r.stability}`);
+  
+  if (r.fieldBased) {
+    console.log(`  🔬 Field-based (${r.evolutionSteps} steps, order=${r.bestFrameOrder.toFixed(2)})`);
+  }
+  
+  // Show output
+  console.log(`\n${r.output}\n`);
+}

package/examples/crt-homology/01-residue-encoding.js

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+/**
+ * Example 01: Residue Encoding with CRT
+ * 
+ * Demonstrates encoding a hidden vector into K residue distributions
+ * over coprime moduli, then reconstructing via Chinese Remainder Theorem.
+ * 
+ * Key concepts:
+ * - r_k = softmax(W_k h + b_k) ∈ Δ(ℤ/p_k) for each prime p_k
+ * - L̂ = Σ_k E[r_k] * M_k * M_k^{-1} mod P (CRT reconstruction)
+ * - Kernel detection: Ker(ℛ) ≈ { r | ε(r) > τ }
+ */
+
+'use strict';
+
+const {
+    ResidueEncoder,
+    CRTReconstructor,
+    DEFAULT_PRIMES_SMALL
+} = require('../../core/crt-homology');
+
+console.log('=== CRT Residue Encoding Example ===\n');
+
+// Use first 4 primes as moduli: [2, 3, 5, 7]
+// Product P = 210
+const primes = DEFAULT_PRIMES_SMALL;
+const hiddenDim = 16;
+
+console.log(`Moduli (primes): ${primes}`);
+console.log(`Product P = ${primes.reduce((a, b) => a * b, 1)}`);
+console.log(`Hidden dimension: ${hiddenDim}\n`);
+
+// Create encoder and reconstructor
+const encoder = new ResidueEncoder(primes, hiddenDim, { initScale: 0.1 });
+const crt = new CRTReconstructor(primes);
+
+// Create a sample hidden vector
+const h = new Float64Array(hiddenDim);
+for (let i = 0; i < hiddenDim; i++) {
+    h[i] = Math.sin(i * 0.5) * 0.5 + 0.5;  // Values in [0, 1]
+}
+
+console.log('Input hidden vector (first 8 dims):');
+console.log('  h =', Array.from(h.slice(0, 8)).map(x => x.toFixed(3)).join(', '), '...\n');
+
+// Encode to residue distributions
+const residues = encoder.encode(h);
+const expectedResidues = encoder.expectedResidues(residues);
+
+console.log('Residue distributions:');
+for (let k = 0; k < primes.length; k++) {
+    const p = primes[k];
+    const r = residues[k];
+    console.log(`  mod ${p}: [${Array.from(r).map(x => x.toFixed(3)).join(', ')}]`);
+    console.log(`  E[r_${k}] = ${expectedResidues[k].toFixed(4)}`);
+}
+
+// CRT reconstruction
+const L = crt.reconstruct(expectedResidues);
+const error = crt.reconstructionError(expectedResidues);
+const validation = crt.validate(expectedResidues);
+
+console.log('\n=== CRT Reconstruction ===');
+console.log(`  Reconstructed L̂ = ${L.toFixed(4)}`);
+console.log(`  Reconstruction error ε(r) = ${error.toFixed(6)}`);
+console.log(`  In kernel: ${validation.inKernel}`);
+console.log(`  Valid (not in kernel): ${validation.valid}`);
+
+// Demonstrate kernel detection with inconsistent residues
+console.log('\n=== Kernel Detection ===');
+console.log('Testing with inconsistent residue tuples:\n');
+
+const testCases = [
+    { residues: [0.5, 1.2, 2.8, 4.1], label: 'Consistent (low error)' },
+    { residues: [0.99, 0.01, 2.5, 3.99], label: 'Boundary values' },
+    { residues: [0.1, 0.2, 0.3, 0.4], label: 'Small residues' }
+];
+
+for (const tc of testCases) {
+    const val = crt.validate(tc.residues, 0.1);
+    console.log(`  ${tc.label}:`);
+    console.log(`    Residues: [${tc.residues.join(', ')}]`);
+    console.log(`    L̂ = ${val.reconstructed.toFixed(2)}, ε = ${val.error.toFixed(4)}`);
+    console.log(`    In kernel: ${val.inKernel}\n`);
+}
+
+console.log('✓ Example complete\n');

package/examples/crt-homology/02-birkhoff-attention.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+/**
+ * Example 02: Birkhoff Polytope Attention
+ * 
+ * Demonstrates projecting attention matrices onto the Birkhoff polytope
+ * using the Sinkhorn-Knopp algorithm.
+ * 
+ * Key concepts:
+ * - Birkhoff polytope = set of doubly-stochastic matrices (row sums = col sums = 1)
+ * - Sinkhorn-Knopp: alternating row/column normalization until convergence
+ * - Physical interpretation: attention as a "transport" operator
+ */
+
+'use strict';
+
+const { BirkhoffProjector } = require('../../core/crt-homology');
+
+console.log('=== Birkhoff Polytope Attention Example ===\n');
+
+// Create projector with 20 Sinkhorn iterations
+const projector = new BirkhoffProjector(20, 1e-10);
+
+// Example 1: Project a random matrix
+console.log('1. Random Matrix Projection:');
+const randomMatrix = [
+    [0.8, 0.2, 0.5],
+    [0.3, 0.9, 0.1],
+    [0.4, 0.6, 0.7]
+];
+
+console.log('   Input matrix:');
+for (const row of randomMatrix) {
+    console.log('   ', row.map(x => x.toFixed(3)).join('  '));
+}
+
+const projected = projector.project(randomMatrix);
+
+console.log('\n   Doubly-stochastic projection:');
+for (const row of projected) {
+    console.log('   ', row.map(x => x.toFixed(3)).join('  '));
+}
+
+// Verify doubly-stochastic property
+const validation = projector.validate(projected, 0.01);
+console.log('\n   Validation:');
+console.log(`     Is doubly-stochastic: ${validation.isDoublyStochastic}`);
+console.log(`     Max row error: ${validation.maxRowError.toFixed(6)}`);
+console.log(`     Max col error: ${validation.maxColError.toFixed(6)}`);
+
+// Example 2: Attention mechanism
+console.log('\n2. Birkhoff Attention:');
+
+// Query, Key, Value matrices (4 tokens, dim=3)
+const Q = [
+    [1.0, 0.5, 0.2],
+    [0.3, 0.8, 0.4],
+    [0.6, 0.1, 0.9],
+    [0.2, 0.7, 0.3]
+];
+
+const K = [
+    [0.9, 0.4, 0.3],
+    [0.2, 0.7, 0.5],
+    [0.5, 0.3, 0.8],
+    [0.4, 0.6, 0.2]
+];
+
+const V = [
+    [1.0, 0.0, 0.0],
+    [0.0, 1.0, 0.0],
+    [0.0, 0.0, 1.0],
+    [0.5, 0.5, 0.0]
+];
+
+console.log('   Queries (Q), Keys (K), Values (V): 4 tokens × 3 dims');
+
+const attentionOutput = projector.attention(Q, K, V);
+
+console.log('\n   Attention output:');
+for (let i = 0; i < attentionOutput.length; i++) {
+    console.log(`     Token ${i}: [${attentionOutput[i].map(x => x.toFixed(3)).join(', ')}]`);
+}
+
+// Example 3: Effect of iterations
+console.log('\n3. Effect of Sinkhorn Iterations:');
+
+const testMatrix = [
+    [2.0, 1.0, 0.5],
+    [0.5, 2.0, 1.0],
+    [1.0, 0.5, 2.0]
+];
+
+for (const iterations of [1, 5, 10, 20]) {
+    const proj = new BirkhoffProjector(iterations);
+    const result = proj.project(testMatrix);
+    const val = proj.validate(result);
+    console.log(`   ${iterations.toString().padStart(2)} iters: max_error = ${val.maxRowError.toFixed(6)}`);
+}
+
+console.log('\n✓ Example complete\n');

package/examples/crt-homology/03-homology-loss.js

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+/**
+ * Example 03: Homology Loss for Consistency Detection
+ * 
+ * Demonstrates detecting "holes" in residue space - consistency failures
+ * that persist under perturbation.
+ * 
+ * Key insight: "Holes are not degrees of freedom. Holes are consistency
+ * failures that persist under perturbation."
+ * 
+ * Key concepts:
+ * - Ker(ℛ) = { r | ε(r) > τ } (kernel = high reconstruction error)
+ * - Cycles in kernel represent semantic inconsistencies
+ * - Betti numbers: β₀ = components, β₁ = holes (1-cycles)
+ * - ℒ_homology = Σ_{cycles} f(cycle) penalizes inconsistency
+ */
+
+'use strict';
+
+const {
+    CRTReconstructor,
+    HomologyLoss,
+    DEFAULT_PRIMES_SMALL
+} = require('../../core/crt-homology');
+
+console.log('=== Homology Loss Example ===\n');
+
+const primes = DEFAULT_PRIMES_SMALL;
+const crt = new CRTReconstructor(primes);
+const homology = new HomologyLoss({
+    tau: 0.1,     // Kernel detection threshold
+    alpha: 1.0,   // Cycle length exponent
+    beta: 1.0,    // Residue weight
+    gamma: 0.5,   // Residue exponent
+    lambda: 1.0   // Overall loss weight
+});
+
+console.log(`Moduli: [${primes.join(', ')}], Product P = ${crt.P}\n`);
+
+// Example 1: Consistent residue batch (no holes)
+console.log('1. Consistent Residue Batch:');
+const consistentBatch = [];
+for (let i = 0; i < 10; i++) {
+    // Generate residues that are consistent (low error)
+    const L = Math.floor(Math.random() * crt.P);
+    const residues = primes.map(p => L % p);
+    consistentBatch.push(residues);
+}
+
+console.log('   Generated 10 consistent residue tuples');
+const consistentResult = homology.compute(consistentBatch, crt);
+console.log(`   Cycles detected: ${consistentResult.cycles}`);
+console.log(`   Homology loss: ${consistentResult.loss.toFixed(6)}`);
+console.log(`   Total points in kernel: ${consistentResult.totalPoints}`);
+
+const betti1 = homology.computeBettiNumbers(consistentBatch, crt);
+console.log(`   Betti numbers: β₀=${betti1.beta0}, β₁=${betti1.beta1}`);
+
+// Example 2: Inconsistent residue batch (with holes)
+console.log('\n2. Inconsistent Residue Batch:');
+const inconsistentBatch = [];
+for (let i = 0; i < 10; i++) {
+    // Generate residues that may be inconsistent
+    // (random values that don't correspond to valid CRT reconstruction)
+    const residues = primes.map(p => Math.random() * p);
+    inconsistentBatch.push(residues);
+}
+
+console.log('   Generated 10 random (potentially inconsistent) residue tuples');
+const inconsistentResult = homology.compute(inconsistentBatch, crt);
+console.log(`   Cycles detected: ${inconsistentResult.cycles}`);
+console.log(`   Homology loss: ${inconsistentResult.loss.toFixed(6)}`);
+console.log(`   Total points in kernel: ${inconsistentResult.totalPoints}`);
+
+const betti2 = homology.computeBettiNumbers(inconsistentBatch, crt);
+console.log(`   Betti numbers: β₀=${betti2.beta0}, β₁=${betti2.beta1}`);
+
+// Example 3: Mixed batch
+console.log('\n3. Mixed Batch (alternating consistent/inconsistent):');
+const mixedBatch = [];
+for (let i = 0; i < 10; i++) {
+    if (i % 2 === 0) {
+        // Consistent
+        const L = Math.floor(Math.random() * crt.P);
+        mixedBatch.push(primes.map(p => L % p));
+    } else {
+        // Inconsistent
+        mixedBatch.push(primes.map(p => Math.random() * p));
+    }
+}
+
+console.log('   Generated 10 mixed residue tuples');
+const mixedResult = homology.compute(mixedBatch, crt);
+console.log(`   Cycles detected: ${mixedResult.cycles}`);
+console.log(`   Homology loss: ${mixedResult.loss.toFixed(6)}`);
+
+if (mixedResult.details.length > 0) {
+    console.log('\n   Cycle details:');
+    for (const detail of mixedResult.details) {
+        console.log(`     Length ${detail.length}: loss=${detail.loss.toFixed(4)}, ` +
+                    `mean_error=${detail.meanError.toFixed(4)}`);
+    }
+}
+
+// Example 4: Persistence analysis
+console.log('\n4. Cycle Persistence (robustness of holes):');
+
+// Create a persistent hole (cluster of inconsistent points)
+const persistentBatch = [];
+for (let i = 0; i < 20; i++) {
+    if (i >= 5 && i <= 10) {
+        // Create a cluster of high-error points
+        persistentBatch.push([0.99, 0.01, 0.5, 0.5]);
+    } else {
+        const L = Math.floor(Math.random() * crt.P);
+        persistentBatch.push(primes.map(p => L % p));
+    }
+}
+
+const cycles = homology.detectCycles(persistentBatch, crt);
+console.log(`   Batch size: 20, Cluster at indices 5-10`);
+console.log(`   Detected ${cycles.length} cycle(s)`);
+
+for (const cycle of cycles) {
+    const persistence = homology.cyclePersistence(cycle);
+    console.log(`     Cycle of length ${cycle.length}: persistence=${persistence.toFixed(4)}`);
+}
+
+const betti3 = homology.computeBettiNumbers(persistentBatch, crt);
+console.log(`   Final Betti numbers: β₀=${betti3.beta0}, β₁=${betti3.beta1}`);
+
+console.log('\n✓ Example complete\n');