@aleph-ai/tinyaleph 1.5.7 → 1.6.1

package/examples/ai/12-neuro-symbolic.js

@@ -0,0 +1,321 @@
+/**
+ * @example Neural-Symbolic Bridge
+ * @description Map neural embeddings to prime-based representations
+ * 
+ * This example shows how to create a bridge between:
+ * - Neural embeddings (from transformers, word2vec, etc.)
+ * - Symbolic prime representations (TinyAleph)
+ * 
+ * Use cases:
+ * - Interpretability: understand what neural embeddings encode
+ * - Grounding: anchor neural representations to symbolic knowledge
+ * - Hybrid reasoning: combine neural flexibility with symbolic precision
+ */
+
+const { SemanticBackend, Hypercomplex } = require('../../modular');
+
+// ===========================================
+// SETUP
+// ===========================================
+
+const backend = new SemanticBackend({ dimension: 16 });
+
+// Simulate neural embeddings (in production, use actual transformer outputs)
+function simulateNeuralEmbedding(text, dim = 384) {
+    // Simulates BERT-like embeddings with higher dimensionality
+    const embedding = new Array(dim).fill(0);
+    const words = text.toLowerCase().split(/\s+/);
+    
+    for (let w = 0; w < words.length; w++) {
+        const word = words[w];
+        for (let i = 0; i < word.length; i++) {
+            const idx = (word.charCodeAt(i) * (w + 1) * (i + 1)) % dim;
+            embedding[idx] += Math.cos(word.charCodeAt(i) * 0.1);
+        }
+    }
+    
+    // Normalize
+    const mag = Math.sqrt(embedding.reduce((s, x) => s + x * x, 0));
+    return embedding.map(x => x / (mag || 1));
+}
+
+// ===========================================
+// NEURAL-SYMBOLIC BRIDGE
+// ===========================================
+
+class NeuroSymbolicBridge {
+    constructor(backend, options = {}) {
+        this.backend = backend;
+        this.neuralDim = options.neuralDim || 384;
+        this.symbolicDim = options.symbolicDim || 16;
+        
+        // Projection matrices (learned in real systems, random here)
+        this.projectionMatrix = this.initProjection();
+        
+        // Symbol grounding table
+        this.groundings = new Map();
+    }
+
+    // Initialize projection matrix
+    initProjection() {
+        // Create a random but fixed projection
+        const matrix = [];
+        for (let i = 0; i < this.symbolicDim; i++) {
+            const row = [];
+            for (let j = 0; j < this.neuralDim; j++) {
+                // Deterministic pseudo-random based on position
+                row.push(Math.sin(i * 7 + j * 13) * Math.cos(i * 11 + j * 17) * 0.1);
+            }
+            matrix.push(row);
+        }
+        return matrix;
+    }
+
+    // Project neural embedding to symbolic space
+    projectToSymbolic(neuralEmbedding) {
+        const symbolic = Hypercomplex.zero(this.symbolicDim);
+        
+        for (let i = 0; i < this.symbolicDim; i++) {
+            let sum = 0;
+            for (let j = 0; j < this.neuralDim; j++) {
+                sum += this.projectionMatrix[i][j] * neuralEmbedding[j];
+            }
+            symbolic.c[i] = sum;
+        }
+        
+        // Normalize
+        return symbolic.normalize();
+    }
+
+    // Get symbolic embedding directly from backend
+    getSymbolic(text) {
+        return this.backend.textToOrderedState(text);
+    }
+
+    // Compute similarity
+    similarity(a, b) {
+        let dot = 0, magA = 0, magB = 0;
+        for (let i = 0; i < a.c.length; i++) {
+            dot += a.c[i] * b.c[i];
+            magA += a.c[i] * a.c[i];
+            magB += b.c[i] * b.c[i];
+        }
+        return dot / (Math.sqrt(magA) * Math.sqrt(magB));
+    }
+
+    // Ground a neural embedding with a symbolic concept
+    ground(name, neuralEmbedding) {
+        const projected = this.projectToSymbolic(neuralEmbedding);
+        const symbolic = this.getSymbolic(name);
+        
+        this.groundings.set(name, {
+            neural: neuralEmbedding,
+            projected,
+            symbolic,
+            alignment: this.similarity(projected, symbolic)
+        });
+        
+        return this.groundings.get(name);
+    }
+
+    // Find the best symbolic grounding for a neural embedding
+    findGrounding(neuralEmbedding) {
+        const projected = this.projectToSymbolic(neuralEmbedding);
+        
+        let best = null;
+        let bestScore = -1;
+        
+        for (const [name, data] of this.groundings) {
+            const score = this.similarity(projected, data.symbolic);
+            if (score > bestScore) {
+                bestScore = score;
+                best = { name, score, data };
+            }
+        }
+        
+        return best;
+    }
+
+    // Analyze the relationship between neural and symbolic
+    analyze(text) {
+        const neural = simulateNeuralEmbedding(text, this.neuralDim);
+        const projected = this.projectToSymbolic(neural);
+        const symbolic = this.getSymbolic(text);
+        
+        return {
+            text,
+            projectedFromNeural: projected,
+            directSymbolic: symbolic,
+            alignment: this.similarity(projected, symbolic),
+            neuralMagnitude: Math.sqrt(neural.reduce((s, x) => s + x * x, 0)),
+            symbolicMagnitude: symbolic.norm()
+        };
+    }
+}
+
+// ===========================================
+// EXAMPLE: BRIDGING NEURAL AND SYMBOLIC
+// ===========================================
+
+console.log('TinyAleph Neural-Symbolic Bridge Example');
+console.log('========================================\n');
+
+const bridge = new NeuroSymbolicBridge(backend);
+
+// Ground some concepts
+console.log('Grounding neural embeddings to symbolic concepts:');
+console.log('─'.repeat(50) + '\n');
+
+const concepts = ['cat', 'dog', 'animal', 'vehicle', 'computer'];
+
+for (const concept of concepts) {
+    const neural = simulateNeuralEmbedding(concept);
+    const grounding = bridge.ground(concept, neural);
+    console.log(`${concept.padEnd(12)} alignment: ${(grounding.alignment * 100).toFixed(1)}%`);
+}
+
+// ===========================================
+// CONCEPT RECOGNITION
+// ===========================================
+
+console.log('\n' + '═'.repeat(50));
+console.log('Recognizing concepts from neural embeddings:');
+console.log('═'.repeat(50) + '\n');
+
+const testPhrases = [
+    'a furry feline pet',
+    'a barking canine friend',
+    'living creatures in nature',
+    'a car driving on the road',
+    'a laptop processing data'
+];
+
+for (const phrase of testPhrases) {
+    const neural = simulateNeuralEmbedding(phrase);
+    const grounding = bridge.findGrounding(neural);
+    
+    console.log(`"${phrase}"`);
+    if (grounding) {
+        console.log(`  → Best match: ${grounding.name} (${(grounding.score * 100).toFixed(1)}%)\n`);
+    } else {
+        console.log(`  → No grounding found\n`);
+    }
+}
+
+// ===========================================
+// ALIGNMENT ANALYSIS
+// ===========================================
+
+console.log('═'.repeat(50));
+console.log('Neural-Symbolic Alignment Analysis:');
+console.log('═'.repeat(50) + '\n');
+
+const analysisTargets = [
+    'The quick brown fox jumps over the lazy dog',
+    'Machine learning algorithms process data',
+    'Abstract concepts are hard to ground',
+    'Simple words are easy'
+];
+
+for (const text of analysisTargets) {
+    const analysis = bridge.analyze(text);
+    console.log(`"${text.substring(0, 40)}..."`);
+    console.log(`  Alignment: ${(analysis.alignment * 100).toFixed(1)}%`);
+    console.log(`  Symbolic magnitude: ${analysis.symbolicMagnitude.toFixed(3)}`);
+    console.log();
+}
+
+// ===========================================
+// HYBRID REASONING EXAMPLE
+// ===========================================
+
+console.log('═'.repeat(50));
+console.log('Hybrid Reasoning (Neural + Symbolic):');
+console.log('═'.repeat(50) + '\n');
+
+class HybridReasoner {
+    constructor(bridge) {
+        this.bridge = bridge;
+        this.rules = [];
+    }
+
+    // Add a symbolic rule
+    addRule(name, condition, conclusion) {
+        this.rules.push({
+            name,
+            conditionEmbed: this.bridge.getSymbolic(condition),
+            conclusionEmbed: this.bridge.getSymbolic(conclusion),
+            conclusion
+        });
+    }
+
+    // Reason from a neural input
+    reason(neuralEmbedding, text = '') {
+        // Project to symbolic
+        const symbolic = this.bridge.projectToSymbolic(neuralEmbedding);
+        
+        // Find matching rules
+        const matches = [];
+        for (const rule of this.rules) {
+            const score = this.bridge.similarity(symbolic, rule.conditionEmbed);
+            if (score > 0.3) {
+                matches.push({ rule, score });
+            }
+        }
+        
+        matches.sort((a, b) => b.score - a.score);
+        
+        return {
+            input: text,
+            symbolicProjection: symbolic,
+            matchedRules: matches.map(m => ({
+                rule: m.rule.name,
+                score: m.score,
+                conclusion: m.rule.conclusion
+            }))
+        };
+    }
+}
+
+const reasoner = new HybridReasoner(bridge);
+
+// Add symbolic rules
+reasoner.addRule('living-mortal', 'living creature that breathes', 'It will eventually die');
+reasoner.addRule('vehicle-fuel', 'vehicle with engine', 'It needs fuel to operate');
+reasoner.addRule('computer-power', 'electronic computing device', 'It requires electricity');
+
+// Test reasoning
+const reasoningTests = [
+    'a breathing animal in the wild',
+    'a truck with a powerful engine',
+    'a smartphone with a processor'
+];
+
+for (const test of reasoningTests) {
+    const neural = simulateNeuralEmbedding(test);
+    const result = reasoner.reason(neural, test);
+    
+    console.log(`Input: "${test}"`);
+    if (result.matchedRules.length > 0) {
+        for (const match of result.matchedRules) {
+            console.log(`  Rule: ${match.rule} (${(match.score * 100).toFixed(0)}%)`);
+            console.log(`  → ${match.conclusion}`);
+        }
+    } else {
+        console.log('  No rules matched');
+    }
+    console.log();
+}
+
+// ===========================================
+// KEY TAKEAWAYS
+// ===========================================
+
+console.log('═'.repeat(50));
+console.log('KEY TAKEAWAYS:');
+console.log('1. Projection maps neural → symbolic space');
+console.log('2. Grounding anchors neural representations');
+console.log('3. Alignment measures neural-symbolic consistency');
+console.log('4. Hybrid reasoning combines flexibility + precision');
+console.log('5. Replace simulated embeddings with real transformers');
+console.log('6. Learn projection matrices from paired data');

package/examples/ai/README.md

@@ -0,0 +1,80 @@
+# AI & Machine Learning Examples
+
+This directory contains examples demonstrating how to use TinyAleph for AI and machine learning applications.
+
+## Examples Overview
+
+| # | File | Description |
+|---|------|-------------|
+| 01 | [`01-embeddings.js`](./01-embeddings.js) | Generate prime-based embeddings for text and concepts |
+| 02 | [`02-semantic-memory.js`](./02-semantic-memory.js) | Build long-term semantic memory for AI agents |
+| 03 | [`03-reasoning.js`](./03-reasoning.js) | Multi-step inference chains with transforms |
+| 04 | [`04-knowledge-graph.js`](./04-knowledge-graph.js) | Build and query prime-based knowledge graphs |
+| 05 | [`05-llm-integration.js`](./05-llm-integration.js) | Integrate TinyAleph with Large Language Models |
+| 06 | [`06-agent.js`](./06-agent.js) | Build a goal-directed reasoning agent |
+| 07 | [`07-hybrid-ai.js`](./07-hybrid-ai.js) | Combine symbolic primes with neural embeddings |
+| 08 | [`08-entropy-reasoning.js`](./08-entropy-reasoning.js) | Use entropy minimization for inference |
+| 09 | [`09-concept-learning.js`](./09-concept-learning.js) | Learn new concepts from examples (few-shot) |
+| 10 | [`10-prompt-primes.js`](./10-prompt-primes.js) | Prime-based prompt engineering |
+| 11 | [`11-rag.js`](./11-rag.js) | Retrieval Augmented Generation pipeline |
+| 12 | [`12-neuro-symbolic.js`](./12-neuro-symbolic.js) | Bridge neural and symbolic representations |
+
+## Running Examples
+
+```bash
+# Run any example
+node examples/ai/01-embeddings.js
+
+# Or from this directory
+cd examples/ai
+node 01-embeddings.js
+```
+
+## Key Concepts
+
+### Prime Embeddings vs Neural Embeddings
+
+TinyAleph's prime-based embeddings offer unique advantages:
+
+| Feature | Prime Embeddings | Neural Embeddings |
+|---------|------------------|-------------------|
+| Deterministic | ✓ Always same output | ✗ Varies with model |
+| Interpretable | ✓ Based on prime structure | ✗ Black box |
+| Order-sensitive | ✓ Non-commutative algebra | △ Context window |
+| Training required | ✗ No training needed | ✓ Requires large data |
+
+### When to Use TinyAleph for AI
+
+- **Semantic Memory**: Store and retrieve by meaning
+- **Reasoning**: Build inference chains with confidence tracking
+- **Grounding**: Anchor neural outputs to symbolic knowledge
+- **Verification**: Check LLM outputs against known facts
+- **Hybrid Systems**: Combine symbolic precision with neural flexibility
+
+## Architecture Patterns
+
+### 1. Memory-Augmented Agent
+```javascript
+const memory = new SemanticMemory(aleph);
+const agent = new SemanticAgent(aleph, 'MyAgent');
+// Agent uses memory for context
+```
+
+### 2. RAG Pipeline
+```javascript
+const store = new DocumentStore(aleph);
+const rag = new RAGPipeline(store);
+const result = rag.query('your question');
+```
+
+### 3. Hybrid Reasoning
+```javascript
+const hybrid = new HybridEmbedding(aleph, { symbolicWeight: 0.6 });
+const embedding = hybrid.getHybrid('concept');
+```
+
+## See Also
+
+- [Quickstart Examples](../) - Get started in 3 minutes
+- [Semantic Examples](../semantic/) - NLP and text processing
+- [Advanced Examples](../advanced/) - Custom backends and transforms

package/examples/arithmetic-topology/01-legendre-symbol.js

@@ -0,0 +1,78 @@
+/**
+ * Example 01: Legendre Symbol Coupling
+ * 
+ * Demonstrates the Legendre symbol (a/p), the mod-2 linking number
+ * analogue in arithmetic topology. This is the foundational pairwise
+ * coupling used in the Arithmetic Link Kernel.
+ * 
+ * Key concepts:
+ * - (a/p) = a^((p-1)/2) mod p
+ * - Returns +1 (quadratic residue), -1 (non-residue), or 0 (divisible)
+ * - Satisfies quadratic reciprocity
+ */
+
+import { LegendreSymbol, computeLegendreMatrix } from '../../core/arithmetic-link-kernel.js';
+
+console.log('=== Legendre Symbol: Pairwise Prime Coupling ===\n');
+
+// 1. Basic Legendre symbol computation
+console.log('1. Computing Legendre symbols:');
+console.log('   (3/7) =', LegendreSymbol.compute(3, 7), '  (3 is a quadratic non-residue mod 7)');
+console.log('   (2/7) =', LegendreSymbol.compute(2, 7), '   (2 is a quadratic residue mod 7)');
+console.log('   (5/11) =', LegendreSymbol.compute(5, 11), '  (5 is a quadratic residue mod 11)');
+console.log('   (7/7) =', LegendreSymbol.compute(7, 7), '   (7 divides 7)\n');
+
+// 2. Quadratic reciprocity verification
+console.log('2. Quadratic Reciprocity:');
+console.log('   For odd primes p, q: (p/q)(q/p) = (-1)^((p-1)/2 * (q-1)/2)');
+
+const testPairs = [[3, 5], [5, 7], [3, 11], [7, 13]];
+for (const [p, q] of testPairs) {
+    const pq = LegendreSymbol.compute(p, q);
+    const qp = LegendreSymbol.compute(q, p);
+    const expected = Math.pow(-1, ((p - 1) / 2) * ((q - 1) / 2));
+    console.log(`   (${p}/${q})(${q}/${p}) = ${pq} × ${qp} = ${pq * qp}, expected = ${expected}`);
+}
+console.log();
+
+// 3. Coupling encodings
+console.log('3. Coupling Encodings:');
+const symbol = LegendreSymbol.compute(3, 7);
+console.log(`   Symbol (3/7) = ${symbol}`);
+console.log('   Bipolar encoding:', LegendreSymbol.toCoupling(symbol, 'bipolar'));
+console.log('   Binary encoding:', LegendreSymbol.toCoupling(symbol, 'binary'));
+console.log('   Phase encoding:', LegendreSymbol.toCoupling(symbol, 'phase'), 'radians\n');
+
+// 4. Coupling matrix for prime set
+console.log('4. Coupling Matrix J for primes {5, 7, 11, 13}:');
+const primes = [5, 7, 11, 13];
+const J = computeLegendreMatrix(primes);
+
+console.log('   J_ij = (p_i / p_j):\n');
+console.log('        p_j =', primes.map(p => String(p).padStart(3)).join(' '));
+for (let i = 0; i < primes.length; i++) {
+    const row = J[i].map(v => String(v).padStart(3)).join(' ');
+    console.log(`   p_i=${primes[i]}:`, row);
+}
+console.log();
+
+// 5. Interpretation for resonance
+console.log('5. Resonance Interpretation:');
+console.log('   J_ij = +1: primes i,j are "in phase" (constructive coupling)');
+console.log('   J_ij = -1: primes i,j are "out of phase" (destructive coupling)');
+console.log('   J_ij = 0:  no coupling (one divides the other)\n');
+
+// Count coupling types
+let positive = 0, negative = 0;
+for (let i = 0; i < primes.length; i++) {
+    for (let j = i + 1; j < primes.length; j++) {
+        if (J[i][j] === 1) positive++;
+        else if (J[i][j] === -1) negative++;
+    }
+}
+console.log(`   Statistics for {${primes.join(', ')}}:`);
+console.log(`   - Constructive pairs: ${positive}`);
+console.log(`   - Destructive pairs: ${negative}`);
+console.log(`   - Net coupling tendency: ${positive > negative ? 'constructive' : 'destructive'}\n`);
+
+console.log('=== End of Example ===');

package/examples/arithmetic-topology/02-redei-symbol.js

@@ -0,0 +1,126 @@
+/**
+ * Example 02: Rédei Symbol and Borromean Primes
+ * 
+ * Demonstrates the Rédei symbol [p₁, p₂, p₃], the arithmetic analogue
+ * of the triple linking number (Milnor's μ(123)). This captures
+ * Borromean-type coherence: three primes with no pairwise coupling
+ * but irreducible triadic coupling.
+ * 
+ * Key concepts:
+ * - [p₁, p₂, p₃] ∈ {±1} when all pairwise Legendre symbols are +1
+ * - Detects irreducible 3-body prime interactions
+ * - Foundation for K³ triadic coupling tensor
+ */
+
+import { 
+    RedeiSymbol, 
+    LegendreSymbol,
+    ArithmeticLinkKernel,
+    quickBorromeanCheck,
+    findBorromeanPrimes
+} from '../../core/arithmetic-link-kernel.js';
+
+console.log('=== Rédei Symbol: Triadic Prime Coupling ===\n');
+
+// 1. Check Rédei computability
+console.log('1. Checking Rédei Symbol Computability:');
+console.log('   Requirements: distinct odd primes with (pᵢ/pⱼ) = 1 for all pairs');
+
+const triples = [
+    [5, 13, 17],
+    [5, 7, 11],
+    [3, 5, 7],
+    [5, 29, 41]
+];
+
+for (const [p1, p2, p3] of triples) {
+    const check = RedeiSymbol.isComputable(p1, p2, p3);
+    const l12 = LegendreSymbol.compute(p1, p2);
+    const l23 = LegendreSymbol.compute(p2, p3);
+    const l31 = LegendreSymbol.compute(p3, p1);
+    
+    console.log(`   [${p1}, ${p2}, ${p3}]: computable=${check.computable}`);
+    console.log(`      Legendre: (${p1}/${p2})=${l12}, (${p2}/${p3})=${l23}, (${p3}/${p1})=${l31}`);
+    if (!check.computable) {
+        console.log(`      Reason: ${check.reason}`);
+    }
+}
+console.log();
+
+// 2. Compute Rédei symbols for valid triples
+console.log('2. Computing Rédei Symbols:');
+for (const [p1, p2, p3] of triples) {
+    const result = RedeiSymbol.compute(p1, p2, p3);
+    if (result.computed) {
+        console.log(`   [${p1}, ${p2}, ${p3}] = ${result.value}`);
+        console.log(`      Method: ${result.method}`);
+    } else {
+        console.log(`   [${p1}, ${p2}, ${p3}]: not computable (${result.reason})`);
+    }
+}
+console.log();
+
+// 3. Borromean primes concept
+console.log('3. Borromean Primes Concept:');
+console.log('   Like Borromean rings: three linked rings where no two are linked,');
+console.log('   Borromean primes have Jᵢⱼ = +1 (split) for all pairs but [p₁,p₂,p₃] ≠ 0\n');
+
+// 4. Quick Borromean check
+console.log('4. Quick Borromean Checks:');
+const candidates = [
+    [5, 13, 17],
+    [5, 29, 41],
+    [17, 41, 73],
+    [5, 7, 11]
+];
+
+for (const [p1, p2, p3] of candidates) {
+    const check = quickBorromeanCheck(p1, p2, p3);
+    console.log(`   (${p1}, ${p2}, ${p3}): possible=${check.possible}`);
+    if (check.isBorromean !== undefined) {
+        console.log(`      isBorromean: ${check.isBorromean}`);
+    }
+    if (check.legendreSymbols) {
+        const ls = check.legendreSymbols;
+        console.log(`      Legendre: l12=${ls.l12}, l23=${ls.l23}, l31=${ls.l31}`);
+    }
+}
+console.log();
+
+// 5. Triadic coupling tensor K³
+console.log('5. Triadic Coupling Tensor K³:');
+const primes = [5, 7, 11, 13, 17, 19, 23];
+const alk = new ArithmeticLinkKernel(primes);
+const K3 = alk.K3;
+
+console.log(`   Prime set: {${primes.join(', ')}}`);
+console.log(`   Computed triadic entries: ${K3.entries.size}`);
+console.log(`   Borromean triples found: ${K3.borromean.length}\n`);
+
+if (K3.entries.size > 0) {
+    console.log('   Sample K³ entries:');
+    let count = 0;
+    for (const [key, entry] of K3.entries) {
+        if (count >= 5) break;
+        const [i, j, k] = entry.indices;
+        console.log(`      K³[${primes[i]},${primes[j]},${primes[k]}] = ${entry.value}`);
+        count++;
+    }
+}
+
+if (K3.borromean.length > 0) {
+    console.log('\n   Borromean triples:');
+    for (const b of K3.borromean.slice(0, 3)) {
+        const ps = b.primes;
+        console.log(`      {${ps.join(', ')}}: value = ${b.value}`);
+    }
+}
+console.log();
+
+// 6. Physical interpretation
+console.log('6. Physical Interpretation for Resonance:');
+console.log('   Pairwise coupling (J): oscillator phase locking via sin(θⱼ - θᵢ)');
+console.log('   Triadic coupling (K³): three-body phase locking via sin(θⱼ + θₖ - 2θᵢ)');
+console.log('   Borromean coherence: synchronization without pairwise locking\n');
+
+console.log('=== End of Example ===');