@aleph-ai/tinyaleph 1.5.6 → 1.6.0

package/examples/formal-semantics/03-lambda-translation.js

@@ -0,0 +1,206 @@
+/**
+ * Example: Lambda Calculus Translation
+ *
+ * Demonstrates the τ translation:
+ * - τ: Term → λ-expression
+ * - Compositional semantics via function application
+ * - Type preservation during translation
+ * - Operational/denotational agreement
+ */
+
+const {
+    N, A, FUSE, CHAIN, SENTENCE, SEQ, IMPL,
+    Translator, LambdaEvaluator, Semantics, ConceptInterpreter,
+    ConstExpr, LamExpr, VarExpr, AppExpr
+} = require('../../core');
+
+console.log('=== Lambda Calculus Translation ===\n');
+
+// ============================================================================
+// 1. Basic Translations
+// ============================================================================
+
+console.log('1. BASIC TRANSLATIONS (τ function)\n');
+
+const translator = new Translator();
+
+// τ(N(p)) = p (constant)
+const noun = N(7);
+const lambdaNoun = translator.translate(noun);
+console.log(`τ(N(7)) = ${lambdaNoun.toString()}`);
+console.log(`  Type: ${JSON.stringify(lambdaNoun.getType())}`);
+console.log(`  Is value: ${lambdaNoun.isValue()}`);
+
+// τ(A(p)) = λx.⊕(p, x)
+const adj = A(3);
+const lambdaAdj = translator.translate(adj);
+console.log(`\nτ(A(3)) = ${lambdaAdj.toString()}`);
+console.log(`  Type: ${JSON.stringify(lambdaAdj.getType())}`);
+
+// τ(FUSE(p,q,r)) = p+q+r
+const fusion = FUSE(3, 5, 11);
+const lambdaFusion = translator.translate(fusion);
+console.log(`\nτ(FUSE(3,5,11)) = ${lambdaFusion.toString()}`);
+console.log(`  Value: ${lambdaFusion.value} (= 3 + 5 + 11)`);
+
+// ============================================================================
+// 2. Chain Translation
+// ============================================================================
+
+console.log('\n2. CHAIN TRANSLATION\n');
+
+// τ(A(p₁)...A(pₖ)N(q)) = ((τ(A(p₁)) ... (τ(A(pₖ)) τ(N(q))))
+const chain = CHAIN([2, 3], N(7));
+const lambdaChain = translator.translate(chain);
+console.log(`τ(${chain.signature()}):`);
+console.log(`  = ${lambdaChain.toString()}`);
+
+// Show the structure
+console.log('\nStructure breakdown:');
+console.log(`  τ(N(7)) = 7`);
+console.log(`  τ(A(3)) = λx₀.(x₀ ⊕ 3)`);
+console.log(`  τ(A(2)) = λx₁.(x₁ ⊕ 2)`);
+console.log(`  Combined: ((λx₁.(x₁ ⊕ 2)) ((λx₀.(x₀ ⊕ 3)) 7))`);
+
+// ============================================================================
+// 3. Lambda Evaluation (β-reduction)
+// ============================================================================
+
+console.log('\n3. LAMBDA EVALUATION (β-reduction)\n');
+
+const evaluator = new LambdaEvaluator();
+
+// Simple examples
+console.log('Evaluating λ-expressions:');
+
+// (λx.x) 5 → 5
+const identity = new LamExpr('x', new VarExpr('x'));
+const app1 = new AppExpr(identity, new ConstExpr(5));
+const result1 = evaluator.evaluate(app1);
+console.log(`  (λx.x) 5 → ${result1.result.toString()} (${result1.steps} steps)`);
+
+// (λx.x) (λy.y) → λy.y
+const app2 = new AppExpr(identity, new LamExpr('y', new VarExpr('y')));
+const result2 = evaluator.evaluate(app2);
+console.log(`  (λx.x)(λy.y) → ${result2.result.toString()}`);
+
+// Evaluating translated terms
+console.log('\nEvaluating translated terms:');
+const chainResult = evaluator.evaluate(lambdaChain);
+console.log(`  τ(A(2)A(3)N(7)) → ${chainResult.result.toString()}`);
+console.log(`  Steps: ${chainResult.steps}`);
+
+// ============================================================================
+// 4. Denotational Semantics
+// ============================================================================
+
+console.log('\n4. DENOTATIONAL SEMANTICS\n');
+
+const semantics = new Semantics();
+
+console.log('Computing denotations [[e]]:');
+
+// [[FUSE(3,5,11)]] = 19
+const d1 = semantics.denote(FUSE(3, 5, 11));
+console.log(`  [[FUSE(3,5,11)]] = ${d1.value}`);
+
+// [[N(7)]] = 7
+const d2 = semantics.denote(N(7));
+console.log(`  [[N(7)]] = ${d2.value}`);
+
+// [[A(2)A(3)N(7)]]
+const d3 = semantics.denote(CHAIN([2, 3], N(7)));
+console.log(`  [[A(2)A(3)N(7)]] = ${d3.value || d3.toString()}`);
+
+// ============================================================================
+// 5. Semantic Equivalence
+// ============================================================================
+
+console.log('\n5. SEMANTIC EQUIVALENCE\n');
+
+// Same terms should be equivalent
+const f1 = FUSE(3, 5, 11);
+const f2 = FUSE(3, 5, 11);
+console.log(`[[FUSE(3,5,11)]] = [[FUSE(3,5,11)]]: ${semantics.equivalent(f1, f2)}`);
+
+// Different fusions with same sum should be equivalent
+const f3 = FUSE(5, 7, 7);  // Would be ill-formed (repeated prime)
+console.log(`Different fusions summing to 19 are semantically equivalent if well-formed`);
+
+// ============================================================================
+// 6. Operational/Denotational Agreement
+// ============================================================================
+
+console.log('\n6. OPERATIONAL/DENOTATIONAL AGREEMENT\n');
+
+console.log('Theorem: If e →* v (operational), then [[e]] = v (denotational)\n');
+
+const terms = [
+    FUSE(3, 5, 11),
+    CHAIN([2], N(7)),
+    CHAIN([2, 3, 5], N(11))
+];
+
+for (const term of terms) {
+    const verification = semantics.verifySemanticEquivalence(term);
+    console.log(`${term.signature()}:`);
+    console.log(`  Operational: ${verification.operational}`);
+    console.log(`  Denotational: ${verification.denotational}`);
+    console.log(`  Agreement: ${verification.equivalent}`);
+}
+
+// ============================================================================
+// 7. Concept Interpretation
+// ============================================================================
+
+console.log('\n7. CONCEPT INTERPRETATION\n');
+
+const interpreter = new ConceptInterpreter();
+
+console.log('Prime → Concept mappings:');
+const conceptPrimes = [2, 3, 5, 7, 11, 13, 17, 19, 23];
+for (const p of conceptPrimes) {
+    const noun = N(p);
+    const concept = interpreter.interpretNoun(noun);
+    console.log(`  N(${p}) → "${concept}"`);
+}
+
+console.log('\nChain interpretation:');
+const chain1 = CHAIN([2, 3], N(7));
+const phrase1 = interpreter.interpretChain(chain1);
+console.log(`  ${chain1.signature()} → "${phrase1}"`);
+
+const chain2 = CHAIN([5, 7], N(11));
+const phrase2 = interpreter.interpretChain(chain2);
+console.log(`  ${chain2.signature()} → "${phrase2}"`);
+
+// Custom concept mappings
+console.log('\nCustom concept mappings:');
+interpreter.addNounConcept(97, 'transcendence');
+interpreter.addNounConcept(101, 'infinity');
+console.log(`  N(97) → "${interpreter.interpretNoun(N(97))}"`);
+console.log(`  N(101) → "${interpreter.interpretNoun(N(101))}"`);
+
+// ============================================================================
+// 8. Sentence Translation
+// ============================================================================
+
+console.log('\n8. SENTENCE TRANSLATION\n');
+
+// Noun sentence
+const s1 = SENTENCE(N(7));
+const lambdaS1 = translator.translate(s1);
+console.log(`τ(SENTENCE(N(7))) = ${lambdaS1.toString()}`);
+
+// Sequential composition
+const s2 = SENTENCE(N(11));
+const seq = SEQ(s1, s2);
+const lambdaSeq = translator.translate(seq);
+console.log(`τ(S₁ ◦ S₂) = ${lambdaSeq.toString()}`);
+
+// Implication
+const impl = IMPL(s1, s2);
+const lambdaImpl = translator.translate(impl);
+console.log(`τ(S₁ ⇒ S₂) = ${lambdaImpl.toString()}`);
+
+console.log('\n=== Done ===');

package/examples/formal-semantics/04-enochian-language.js

@@ -0,0 +1,257 @@
+/**
+ * Example: Enochian Formal Language System
+ *
+ * Demonstrates the Enochian language system:
+ * - 21-letter alphabet with prime mappings
+ * - Prime basis PE = {7, 11, 13, 17, 19, 23, 29}
+ * - Twist operations κ(p) = 360/p
+ * - Core vocabulary and The 19 Calls
+ * - Sedenion (16D) integration
+ */
+
+const {
+    ENOCHIAN_ALPHABET,
+    letterToPrime,
+    primeToLetter,
+    PRIME_BASIS,
+    BASIS_MEANINGS,
+    TWIST_MODES,
+    twistAngle,
+    twistRadians,
+    TwistOperator,
+    validateTwistClosure,
+    EnochianWord,
+    CORE_VOCABULARY,
+    wordLookup,
+    EnochianCall,
+    THE_NINETEEN_CALLS,
+    SedenionElement,
+    EnochianEngine
+} = require('../../apps/sentient/lib/enochian-vocabulary');
+
+console.log('=== Enochian Formal Language System ===\n');
+
+// ============================================================================
+// 1. The Enochian Alphabet
+// ============================================================================
+
+console.log('1. THE ENOCHIAN ALPHABET (21 Letters)\n');
+
+console.log('Letter | Name    | Prime | Meaning');
+console.log('-------|---------|-------|-------------');
+for (const entry of ENOCHIAN_ALPHABET.slice(0, 10)) {
+    console.log(`   ${entry.letter}   | ${entry.name.padEnd(7)} | ${String(entry.prime).padStart(5)} | ${entry.meaning}`);
+}
+console.log('   ... (11 more letters)\n');
+
+console.log('Letter → Prime mappings:');
+console.log(`  A → ${letterToPrime.get('A')} (beginning)`);
+console.log(`  D → ${letterToPrime.get('D')} (foundation)`);
+console.log(`  E → ${letterToPrime.get('E')} (light)`);
+console.log(`  Z → ${letterToPrime.get('Z')} (completion)`);
+
+// ============================================================================
+// 2. Prime Basis PE
+// ============================================================================
+
+console.log('\n2. PRIME BASIS PE = {7, 11, 13, 17, 19, 23, 29}\n');
+
+console.log('The seven foundational primes and their meanings:');
+for (const p of PRIME_BASIS) {
+    console.log(`  ${p}: ${BASIS_MEANINGS.get(p)}`);
+}
+
+// ============================================================================
+// 3. Twist Operations
+// ============================================================================
+
+console.log('\n3. TWIST OPERATIONS\n');
+
+console.log('Twist angle κ(p) = 360°/p:\n');
+
+const twistPrimes = [7, 11, 13, 17, 19, 23, 29];
+for (const p of twistPrimes) {
+    const angle = twistAngle(p);
+    const radians = twistRadians(p);
+    console.log(`  κ(${p.toString().padStart(2)}) = ${angle.toFixed(2)}° = ${radians.toFixed(4)} rad`);
+}
+
+// Twist operators
+console.log('\nTwist operators:');
+const twist7 = new TwistOperator(7);
+const twist11 = new TwistOperator(11, TWIST_MODES.MU);
+
+console.log(`  ${twist7.toString()}`);
+console.log(`  ${twist11.toString()}`);
+
+// 2D rotation
+const rotated = twist7.apply2D(1, 0);
+console.log(`\n  Applying twist(7) to (1, 0):`);
+console.log(`    Result: (${rotated.x.toFixed(4)}, ${rotated.y.toFixed(4)})`);
+
+// Twist closure validation
+console.log('\nTwist closure validation:');
+const closure1 = validateTwistClosure([7, 11, 13, 17, 19, 23, 29]);
+console.log(`  PE basis total angle: ${closure1.totalAngle.toFixed(2)}°`);
+console.log(`  Revolutions: ${closure1.revolutions}`);
+console.log(`  Is closed: ${closure1.valid}`);
+
+// ============================================================================
+// 4. Enochian Words
+// ============================================================================
+
+console.log('\n4. ENOCHIAN WORDS\n');
+
+// Create some words
+const zacar = new EnochianWord('ZACAR', 'Move', { category: 'command' });
+const zorge = new EnochianWord('ZORGE', 'Be friendly unto me', { category: 'invocation' });
+
+console.log('Word: ZACAR (Move)');
+console.log(`  Primes: [${zacar.primes.join(', ')}]`);
+console.log(`  Product: ${zacar.primeProduct}`);
+console.log(`  Twist sum: ${zacar.twistSum.toFixed(2)}°`);
+console.log(`  Closure: ${JSON.stringify(zacar.getTwistClosure())}`);
+
+console.log('\nWord: ZORGE (Be friendly unto me)');
+console.log(`  Primes: [${zorge.primes.join(', ')}]`);
+console.log(`  Product: ${zorge.primeProduct}`);
+console.log(`  Twist sum: ${zorge.twistSum.toFixed(2)}°`);
+
+// Resonance between words
+const resonance = zacar.resonanceWith(zorge);
+console.log('\nResonance between ZACAR and ZORGE:');
+console.log(`  Shared primes: [${resonance.sharedPrimes.join(', ')}]`);
+console.log(`  Resonance score: ${resonance.resonanceScore.toFixed(4)}`);
+console.log(`  Harmonic ratio: ${resonance.harmonicRatio.toFixed(4)}`);
+
+// ============================================================================
+// 5. Core Vocabulary
+// ============================================================================
+
+console.log('\n5. CORE VOCABULARY\n');
+
+console.log(`Total words in vocabulary: ${CORE_VOCABULARY.length}\n`);
+
+console.log('Sample words by category:');
+const categories = ['command', 'invocation', 'noun', 'verb', 'element'];
+for (const cat of categories) {
+    const words = CORE_VOCABULARY.filter(w => w.category === cat).slice(0, 2);
+    if (words.length > 0) {
+        console.log(`  ${cat}:`);
+        for (const w of words) {
+            console.log(`    ${w.word} - "${w.meaning}"`);
+        }
+    }
+}
+
+// ============================================================================
+// 6. The 19 Calls
+// ============================================================================
+
+console.log('\n6. THE 19 CALLS (Keys)\n');
+
+console.log(`Total calls: ${THE_NINETEEN_CALLS.length}\n`);
+
+console.log('The 19 Calls:');
+for (const call of THE_NINETEEN_CALLS.slice(0, 5)) {
+    console.log(`  ${call.number}. ${call.name}`);
+    console.log(`     Purpose: ${call.purpose}`);
+}
+console.log('  ... (14 more calls)\n');
+
+// Call analysis
+const call1 = THE_NINETEEN_CALLS[0];
+console.log(`Analysis of Call 1 (${call1.name}):`);
+console.log(`  Words: [${call1.words.join(', ')}]`);
+console.log(`  Total primes: ${call1.getAllPrimes().length}`);
+const callTwist = call1.getTotalTwist();
+console.log(`  Total twist: ${callTwist.totalAngle.toFixed(2)}°`);
+console.log(`  Signature: ${call1.getPrimeSignature()}`);
+
+// ============================================================================
+// 7. Sedenion Integration (16D)
+// ============================================================================
+
+console.log('\n7. SEDENION INTEGRATION (16D)\n');
+
+// Create sedenion from word
+const wordSed = SedenionElement.fromWord(zacar);
+console.log('Sedenion from "ZACAR":');
+console.log(`  Norm: ${wordSed.norm().toFixed(4)}`);
+console.log(`  Components: [${wordSed.components.slice(0, 4).map(c => c.toFixed(4)).join(', ')}, ...]`);
+
+// Sedenion operations
+const sed1 = new SedenionElement([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+const sed2 = new SedenionElement([0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+
+console.log('\nSedenion operations:');
+console.log(`  s1 = 1 (real unit)`);
+console.log(`  s2 = e₁ (first imaginary unit)`);
+
+const sum = sed1.add(sed2);
+console.log(`  s1 + s2 = ${sum.toString()}`);
+
+const conj = sed2.conjugate();
+console.log(`  conj(s2) = ${conj.toString()}`);
+
+// Twist in 16D
+const twisted = wordSed.twist(7);
+console.log('\nTwisting sedenion by prime 7:');
+console.log(`  Original norm: ${wordSed.norm().toFixed(4)}`);
+console.log(`  Twisted norm: ${twisted.norm().toFixed(4)}`);
+console.log(`  Norm preserved: ${Math.abs(wordSed.norm() - twisted.norm()) < 0.0001}`);
+
+// ============================================================================
+// 8. Enochian Engine
+// ============================================================================
+
+console.log('\n8. ENOCHIAN ENGINE\n');
+
+const engine = new EnochianEngine();
+
+// Parse text
+console.log('Parsing Enochian text:');
+const parsed = engine.parse('OL SONF VORS GOHE');
+console.log(`  Input: "OL SONF VORS GOHE"`);
+console.log(`  Parsed words: ${parsed.length}`);
+for (const word of parsed) {
+    console.log(`    ${word.word} - "${word.meaning}"`);
+}
+
+// Prime signature
+console.log('\nPrime signature:');
+const sig = engine.primeSignature('ZACAR ZAMRAN');
+console.log(`  "ZACAR ZAMRAN" → [${sig.join(', ')}]`);
+
+// Convert to sedenion
+console.log('\nSedenion representation:');
+const sed = engine.toSedenion('ZACAR');
+console.log(`  "ZACAR" → sedenion with norm ${sed.norm().toFixed(4)}`);
+
+// Resonance between texts
+console.log('\nResonance computation:');
+const res = engine.resonance('ZACAR', 'ZORGE');
+console.log(`  resonance("ZACAR", "ZORGE") = ${res.toFixed(4)}`);
+
+// Execute a call
+console.log('\nExecuting Call 1:');
+const callResult = engine.executeCall(1);
+console.log(`  Sedenion norm: ${callResult.norm.toFixed(4)}`);
+console.log(`  Twist closure valid: ${callResult.twistClosure.valid}`);
+
+// Basis decomposition
+console.log('\nBasis decomposition:');
+const decomp = engine.basisDecomposition('ZACAR ZORGE');
+console.log(`  Basis counts: ${JSON.stringify(decomp.basisCounts)}`);
+console.log(`  Basis ratio: ${(decomp.basisRatio * 100).toFixed(1)}%`);
+console.log(`  Non-basis primes: [${decomp.nonBasisPrimes.join(', ')}]`);
+
+// Find resonant words
+console.log('\nFinding words resonant with prime 7:');
+const resonant = engine.findResonantWords(7);
+console.log(`  Found ${resonant.length} words containing prime 7`);
+if (resonant.length > 0) {
+    console.log(`  Examples: ${resonant.slice(0, 3).map(w => w.word).join(', ')}`);
+}
+
+console.log('\n=== Done ===');

package/examples/formal-semantics/README.md

@@ -0,0 +1,98 @@
+# Formal Semantics Examples
+
+These examples demonstrate the formal semantic systems for prime-indexed computation.
+
+## Examples
+
+### 1. Typed Terms (`01-typed-terms.js`)
+
+Demonstrates the type system:
+- N(p): Noun terms indexed by prime
+- A(p): Adjective/operator terms with p < q constraint
+- ChainTerm: Operator chains A(p₁)...A(pₖ)N(q)
+- FusionTerm: Triadic fusion FUSE(p,q,r)
+- Sentence composition (◦) and implication (⇒)
+
+```bash
+node examples/formal-semantics/01-typed-terms.js
+```
+
+### 2. Reduction Semantics (`02-reduction.js`)
+
+Demonstrates the operational semantics:
+- Small-step reduction (→)
+- Prime-preserving operators (⊕)
+- Strong normalization proof
+- Confluence via Newman's Lemma
+- Fusion canonicalization
+
+```bash
+node examples/formal-semantics/02-reduction.js
+```
+
+### 3. Lambda Translation (`03-lambda-translation.js`)
+
+Demonstrates the τ translation:
+- τ: Term → λ-expression
+- Compositional semantics
+- Type preservation
+- Operational/denotational agreement
+- Concept interpretation
+
+```bash
+node examples/formal-semantics/03-lambda-translation.js
+```
+
+### 4. Enochian Language (`04-enochian-language.js`)
+
+Demonstrates the Enochian formal system:
+- 21-letter alphabet with prime mappings
+- Prime basis PE = {7, 11, 13, 17, 19, 23, 29}
+- Twist operations κ(p) = 360/p
+- The 19 Calls
+- Sedenion (16D) integration
+
+```bash
+node examples/formal-semantics/04-enochian-language.js
+```
+
+## Running All Examples
+
+```bash
+cd examples/formal-semantics
+for f in *.js; do echo "=== $f ==="; node "$f"; echo; done
+```
+
+## Key Concepts
+
+### Type System
+
+| Type | Description | Example |
+|------|-------------|---------|
+| N(p) | Noun indexed by prime p | N(7) = "truth" |
+| A(p) | Adjective with constraint p < q | A(3) = "triple" modifier |
+| S | Sentence-level proposition | [N(7)] = statement |
+
+### Reduction Rules 
+
+| Rule | Reduction | Description |
+|------|-----------|-------------|
+| FUSE | FUSE(p,q,r) → N(p+q+r) | Triadic fusion |
+| APPLY | A(p)N(q) → N(q⊕p) | Operator application |
+
+### Enochian Primes
+
+| Letter | Prime | Meaning |
+|--------|-------|---------|
+| A | 2 | Beginning |
+| D | 7 | Foundation |
+| E | 11 | Light |
+| G | 17 | Spirit |
+| Z | 73 | Completion |
+
+## Related Files
+
+- `core/types.js` - Type system implementation
+- `core/reduction.js` - Reduction semantics
+- `core/lambda.js` - Lambda calculus translation
+- `apps/sentient/lib/enochian-vocabulary.js` - Enochian language