@aleph-ai/tinyaleph 1.0.2 → 1.1.0

package/README.md

@@ -14,6 +14,10 @@ A novel computational paradigm that encodes meaning as prime number signatures,
 - **Oscillator Dynamics**: Kuramoto-model synchronization for coherent reasoning
 - **Entropy Minimization**: Reasoning as reduction of semantic uncertainty
 - **Multiple Backends**: Semantic (NLP), Cryptographic (hashing), Scientific (quantum-inspired)
+- **Formal Type System**: Typed term calculus with N(p)/A(p)/S types and ordering constraints
+- **Reduction Semantics**: Strong normalization with prime-preserving operators
+- **Lambda Translation**: Model-theoretic semantics via λ-calculus embedding
+- **Enochian Vocabulary**: 21-letter angelic alphabet with prime basis and sedenion operations
 
 ## Installation
 
@@ -167,6 +171,40 @@ kuramoto.step(0.01);
 console.log('Order parameter:', kuramoto.orderParameter());
 ```
 
+### Extended Synchronization Models
+
+Five advanced Kuramoto-family models for complex synchronization dynamics:
+
+```javascript
+const {
+  NetworkKuramoto,      // Topology-aware coupling
+  AdaptiveKuramoto,     // Hebbian plasticity
+  SakaguchiKuramoto,    // Phase frustration (chimera states)
+  SmallWorldKuramoto,   // Watts-Strogatz topology
+  MultiSystemCoupling   // Cross-system synchronization
+} = require('@aleph-ai/tinyaleph');
+
+// Network Kuramoto with custom topology
+const network = new NetworkKuramoto(frequencies, adjacencyMatrix, 0.5);
+network.setFromEntanglementGraph(entanglementGraph, primeList);
+
+// Adaptive Kuramoto with Hebbian learning
+const adaptive = new AdaptiveKuramoto(frequencies, 0.3, 0.02);
+// Coupling evolves: "concepts that sync together link together"
+
+// Sakaguchi-Kuramoto with phase frustration
+const sakaguchi = new SakaguchiKuramoto(frequencies, 0.5, Math.PI/4);
+console.log('State:', sakaguchi.classifyState()); // synchronized/chimera/incoherent
+
+// Small-world topology
+const smallWorld = new SmallWorldKuramoto(frequencies, 4, 0.1, 0.5);
+console.log('Small-world coefficient:', smallWorld.smallWorldCoefficient());
+
+// Multi-system coupling (hierarchical or peer-to-peer)
+const multi = new MultiSystemCoupling([system1, system2, system3]);
+console.log('Inter-system coherence:', multi.interSystemCoherence());
+```
+
 ### Entropy and Stability
 
 ```javascript
@@ -180,6 +218,126 @@ const lambda = estimateLyapunov(entropyTimeSeries);
 console.log('Stable:', lambda < 0);
 ```
 
+## Formal Semantics
+
+### Typed Term Calculus
+
+The library implements a formal type system for prime-based compositional semantics:
+
+```javascript
+const { N, A, FUSE, CHAIN, SENTENCE, TypeChecker } = require('@aleph-ai/tinyaleph');
+
+// Create typed terms
+const noun7 = N(7);      // N(7) - noun indexed by prime 7
+const adj3 = A(3);       // A(3) - adjective indexed by prime 3
+
+// Adjective application with ordering constraint (p < q)
+const chain = adj3.apply(noun7);  // A(3)N(7) is valid since 3 < 7
+
+// Triadic fusion where p+q+r is prime
+const fused = FUSE(3, 5, 11);  // 3+5+11 = 19 (prime) ✓
+
+// Sentence composition
+const s1 = SENTENCE(7);
+const s2 = SENTENCE(11);
+const compound = SEQ(s1, s2);  // s₁ ◦ s₂
+
+// Type checking
+const checker = new TypeChecker();
+console.log(checker.inferType(noun7));  // 'N'
+console.log(checker.checkApplication(adj3, noun7));  // { valid: true }
+```
+
+### Reduction Semantics
+
+Strong normalization with prime-preserving operators:
+
+```javascript
+const {
+    ReductionSystem,
+    ResonanceOperator,
+    NextPrimeOperator,
+    demonstrateStrongNormalization
+} = require('@aleph-ai/tinyaleph');
+
+// Create reduction system
+const reduction = new ReductionSystem();
+
+// Add prime-preserving operators
+reduction.addOperator(new ResonanceOperator(2));    // Resonance at p=2
+reduction.addOperator(new NextPrimeOperator());      // Map to next prime
+
+// Normalize a term sequence
+const result = reduction.normalize([7, 11, 13]);
+console.log(result.normalForm);    // Canonical form
+console.log(result.steps);         // Reduction trace
+
+// Demonstrate strong normalization
+const proof = demonstrateStrongNormalization([3, 5, 7], reduction);
+console.log(proof.terminates);     // true (guaranteed!)
+```
+
+### Lambda Calculus Translation
+
+Model-theoretic semantics via τ translation:
+
+```javascript
+const {
+    Translator,
+    LambdaEvaluator,
+    Semantics
+} = require('@aleph-ai/tinyaleph');
+
+// Translate prime terms to λ-expressions
+const translator = new Translator();
+const lambda = translator.translateNoun(N(7));  // Constant 7
+const appLambda = translator.translateChain(chain);
+
+// Evaluate λ-expressions
+const evaluator = new LambdaEvaluator();
+const normal = evaluator.normalize(appLambda);
+
+// Model-theoretic interpretation
+const semantics = new Semantics();
+semantics.domain = [2, 3, 5, 7, 11, 13];  // Prime domain
+const value = semantics.interpret(N(7));   // 7
+```
+
+### Enochian Vocabulary
+
+The 21-letter angelic alphabet with prime basis and sedenion operations:
+
+```javascript
+const {
+    EnochianEngine,
+    ENOCHIAN_ALPHABET,
+    PRIME_BASIS,
+    CORE_VOCABULARY,
+    SedenionElement
+} = require('@aleph-ai/tinyaleph/apps/sentient/lib/enochian-vocabulary');
+
+// 21-letter alphabet with prime mappings
+console.log(ENOCHIAN_ALPHABET['A']);  // { prime: 3, value: 1, angle: 51.43 }
+console.log(PRIME_BASIS);  // [7, 11, 13, 17, 19, 23, 29]
+
+// Enochian engine for word processing
+const engine = new EnochianEngine();
+
+// Parse and compute word prime value
+const parsed = engine.parseWord('MADRIAX');  // "O ye heavens"
+console.log(parsed.primeValue);
+console.log(parsed.letters);
+
+// Sedenion operations (16-dimensional)
+const s1 = new SedenionElement([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+const s2 = new SedenionElement([0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+const product = s1.multiply(s2);  // Non-commutative!
+
+// Access core vocabulary (35+ Enochian words)
+console.log(CORE_VOCABULARY['OL']);     // "I" (first person)
+console.log(CORE_VOCABULARY['ZORGE']);  // "be friendly unto"
+```
+
 ## API Overview
 
 ### Main Exports
@@ -194,9 +352,36 @@ console.log('Stable:', lambda < 0);
 | `Hypercomplex` | Sedenion algebra |
 | `Oscillator` / `OscillatorBank` | Phase-amplitude oscillators |
 | `KuramotoModel` | Coupled oscillator synchronization |
+| `NetworkKuramoto` | Topology-aware coupling |
+| `AdaptiveKuramoto` | Hebbian plasticity |
+| `SakaguchiKuramoto` | Phase frustration / chimera states |
+| `SmallWorldKuramoto` | Watts-Strogatz topology |
+| `MultiSystemCoupling` | Cross-system synchronization |
 | `hash(input)` | Quick semantic hash |
 | `deriveKey(pass, salt)` | Quick key derivation |
 
+### Formal Semantics Exports
+
+| Export | Description |
+|--------|-------------|
+| `N(prime)` | Create noun term N(p) |
+| `A(prime)` | Create adjective term A(p) |
+| `FUSE(p, q, r)` | Create triadic fusion |
+| `CHAIN(ops, noun)` | Create operator chain |
+| `SENTENCE(expr)` | Create sentence from noun |
+| `SEQ(s1, s2)` | Sequential composition |
+| `IMPL(s1, s2)` | Implication |
+| `TypeChecker` | Type inference and checking |
+| `ReductionSystem` | Reduction semantics engine |
+| `ResonanceOperator` | Prime resonance operator |
+| `NextPrimeOperator` | Next prime mapping |
+| `ModularOperator` | Modular arithmetic |
+| `Translator` | λ-calculus translation |
+| `LambdaEvaluator` | β-reduction evaluator |
+| `Semantics` | Model-theoretic interpretation |
+| `EnochianEngine` | Enochian language processing |
+| `SedenionElement` | 16D hypercomplex operations |
+
 ### Sub-modules
 
 ```javascript
@@ -224,6 +409,12 @@ Full documentation is available in the `docs/` directory:
   
 - **[Reference](./docs/reference/README.md)**: Complete API documentation
   - Core module, physics module, backends, engine
+  
+- **[Formal Semantics Examples](./examples/formal-semantics/README.md)**: New formal system demos
+  - Typed terms and type checking
+  - Reduction and normalization
+  - Lambda translation
+  - Enochian language
 
 ## Examples
 
@@ -241,6 +432,12 @@ npm run benchmark
 
 # Interactive chat
 npm run chat
+
+# Formal semantics examples
+node examples/formal-semantics/01-typed-terms.js
+node examples/formal-semantics/02-reduction.js
+node examples/formal-semantics/03-lambda-translation.js
+node examples/formal-semantics/04-enochian-language.js
 ```
 
 ## Architecture
@@ -263,6 +460,28 @@ npm run chat
 │ • Prime encode  │ │ • Key derive    │ │ • Wave collapse │
 │ • Transforms    │ │ • Verify        │ │ • Measurement   │
 └─────────────────┘ └─────────────────┘ └─────────────────┘
+
+┌─────────────────────────────────────────────────────────────────┐
+│                     Formal Semantics Layer                       │
+├─────────────────┬─────────────────┬─────────────────────────────┤
+│   Type System   │   Reduction     │   Lambda Translation        │
+│                 │                 │                             │
+│ • N(p), A(p), S │ • Small-step →  │ • τ: Terms → λ-expressions  │
+│ • FUSE(p,q,r)   │ • ⊕ operators   │ • β-reduction               │
+│ • ◦ composition │ • Normal forms  │ • Model interpretation      │
+│ • ⇒ implication │ • Confluence    │ • Semantic domains          │
+└─────────────────┴─────────────────┴─────────────────────────────┘
+
+┌─────────────────────────────────────────────────────────────────┐
+│                     Enochian Language Module                     │
+├─────────────────────────────────────────────────────────────────┤
+│ • 21-letter alphabet with prime mappings                         │
+│ • Prime basis PE = {7, 11, 13, 17, 19, 23, 29}                  │
+│ • Twist angles κ(p) = 360/p degrees                              │
+│ • 16-dimensional sedenion operations                             │
+│ • Core vocabulary (35+ words)                                    │
+│ • The Nineteen Calls (traditional invocations)                   │
+└─────────────────────────────────────────────────────────────────┘
 ```
 
 ## Requirements

package/core/index.js

@@ -3,6 +3,33 @@
  */
 
 const { Hypercomplex } = require('./hypercomplex');
+
+// Formal Type System (mtspbc.pdf implementation)
+const {
+  NounType, AdjType, SentenceType,
+  NounTerm, AdjTerm, ChainTerm, FusionTerm,
+  NounSentence, SeqSentence, ImplSentence,
+  TypingContext, TypingJudgment, TypeChecker,
+  N, A, FUSE, CHAIN, SENTENCE, SEQ, IMPL
+} = require('./types');
+
+// Reduction Semantics (ncpsc.pdf implementation)
+const {
+  PrimeOperator, NextPrimeOperator, ModularPrimeOperator,
+  ResonancePrimeOperator, IdentityPrimeOperator, DEFAULT_OPERATOR,
+  ReductionStep, ReductionTrace, ReductionSystem,
+  isNormalForm, isReducible, termSize,
+  FusionCanonicalizer, NormalFormVerifier,
+  demonstrateStrongNormalization, testLocalConfluence
+} = require('./reduction');
+
+// Lambda Calculus Translation (Section 4 from mtspbc.pdf)
+const {
+  LambdaExpr, VarExpr, ConstExpr, LamExpr, AppExpr,
+  PairExpr, ImplExpr, PrimOpExpr,
+  Translator, TypeDirectedTranslator,
+  LambdaEvaluator, Semantics, ConceptInterpreter
+} = require('./lambda');
 const {
   FANO_LINES,
   octonionMultiplyIndex,
@@ -129,5 +156,60 @@ module.exports = {
   applyResonanceOperator,
   
   // TensorFlow.js ResoFormer layers (if available)
-  ...(rformerTF || {})
+  ...(rformerTF || {}),
+  
+  // Formal Type System (mtspbc.pdf)
+  NounType,
+  AdjType,
+  SentenceType,
+  NounTerm,
+  AdjTerm,
+  ChainTerm,
+  FusionTerm,
+  NounSentence,
+  SeqSentence,
+  ImplSentence,
+  TypingContext,
+  TypingJudgment,
+  TypeChecker,
+  N,
+  A,
+  FUSE,
+  CHAIN,
+  SENTENCE,
+  SEQ,
+  IMPL,
+  
+  // Reduction Semantics (ncpsc.pdf)
+  PrimeOperator,
+  NextPrimeOperator,
+  ModularPrimeOperator,
+  ResonancePrimeOperator,
+  IdentityPrimeOperator,
+  DEFAULT_OPERATOR,
+  ReductionStep,
+  ReductionTrace,
+  ReductionSystem,
+  isNormalForm,
+  isReducible,
+  termSize,
+  FusionCanonicalizer,
+  NormalFormVerifier,
+  demonstrateStrongNormalization,
+  testLocalConfluence,
+  
+  // Lambda Calculus Translation
+  LambdaExpr,
+  VarExpr,
+  ConstExpr,
+  LamExpr,
+  AppExpr,
+  PairExpr,
+  ImplExpr,
+  PrimOpExpr,
+  Translator,
+  TypeDirectedTranslator,
+  LambdaEvaluator,
+  Semantics,
+  ConceptInterpreter
 };