@aleph-ai/tinyaleph 1.0.2 → 1.2.0

package/docs/reference/README.md

@@ -13,6 +13,9 @@ The foundational mathematical primitives:
 - **Fano** - Fano plane multiplication tables for octonions
 - **Sieve** - Semantic sieve algorithm for concept filtering
 - **LLM** - LLM coupling utilities
+- **Types** - Formal type system with N(p)/A(p)/S types
+- **Reduction** - Reduction semantics and normalization
+- **Lambda** - λ-calculus translation and evaluation
 
 ### [Physics Module](./02-physics.md)
 
@@ -41,6 +44,28 @@ High-level orchestration:
 - **createEngine** - Factory function for engine creation
 - **registerBackend** - Backend registration system
 
+### [Formal Semantics Module](./05-formal-semantics.md)
+
+Formal type system and reduction semantics:
+
+- **Types** - NounTerm, AdjTerm, ChainTerm, FusionTerm, SentenceTerm
+- **TypeChecker** - Type inference and checking
+- **ReductionSystem** - Small-step reduction with ⊕ operators
+- **Translator** - τ translation to λ-calculus
+- **LambdaEvaluator** - β-reduction and normalization
+- **Semantics** - Model-theoretic interpretation
+
+### [Enochian Module](./06-enochian.md)
+
+The angelic language system:
+
+- **EnochianEngine** - Word parsing and computation
+- **ENOCHIAN_ALPHABET** - 21-letter alphabet with prime mappings
+- **PRIME_BASIS** - The seven foundation primes
+- **CORE_VOCABULARY** - Traditional Enochian words
+- **SedenionElement** - 16-dimensional operations
+- **TwistOperator** - Angular transformations
+
 ---
 
 ## Quick Reference
@@ -241,6 +266,9 @@ console.assert(coherence >= 0 && coherence <= 1);
 | fano | `core/fano.js` | Fano plane |
 | sieve | `core/sieve.js` | Semantic sieve |
 | llm | `core/llm.js` | LLM coupling |
+| types | `core/types.js` | Formal type system |
+| reduction | `core/reduction.js` | Reduction semantics |
+| lambda | `core/lambda.js` | λ-calculus translation |
 | oscillator | `physics/oscillator.js` | Oscillator creation |
 | kuramoto | `physics/kuramoto.js` | Synchronization |
 | entropy | `physics/entropy.js` | Information theory |
@@ -249,4 +277,252 @@ console.assert(coherence >= 0 && coherence <= 1);
 | semantic | `backends/semantic/index.js` | Semantic backend |
 | cryptographic | `backends/cryptographic/index.js` | Crypto backend |
 | scientific | `backends/scientific/index.js` | Science backend |
-| engine | `engine/aleph.js` | Main engine |
+| engine | `engine/aleph.js` | Main engine |
+| enochian | `apps/sentient/lib/enochian-vocabulary.js` | Enochian language |
+
+---
+
+## Formal Semantics API
+
+### Type System (`core/types.js`)
+
+```typescript
+// Type constants
+Types.NOUN       // 'N'
+Types.ADJECTIVE  // 'A'
+Types.SENTENCE   // 'S'
+
+// Term classes
+class NounTerm {
+  constructor(prime: number);
+  isWellFormed(): boolean;
+  interpret(): number;
+  equals(other: NounTerm): boolean;
+}
+
+class AdjTerm {
+  constructor(prime: number);
+  canApplyTo(noun: NounTerm): boolean;  // p < q constraint
+  apply(noun: NounTerm): ChainTerm;
+}
+
+class ChainTerm {
+  constructor(operators: AdjTerm[], noun: NounTerm);
+  prepend(operator: AdjTerm): ChainTerm;
+  getAllPrimes(): number[];
+}
+
+class FusionTerm {
+  constructor(p: number, q: number, r: number);
+  isWellFormed(): boolean;  // p+q+r is prime
+  getFusedPrime(): number;
+  static findTriads(target: number): FusionTerm[];
+}
+
+// Sentence classes
+class NounSentence {
+  constructor(nounExpr: NounTerm | ChainTerm | FusionTerm);
+  getDiscourseState(): number[];
+}
+
+class SeqSentence {
+  constructor(left: SentenceTerm, right: SentenceTerm);
+  getDiscourseState(): number[];  // Concatenation
+}
+
+class ImplSentence {
+  constructor(antecedent: SentenceTerm, consequent: SentenceTerm);
+  holds(): boolean;  // Prefix entailment
+}
+
+// Type checking
+class TypeChecker {
+  inferType(term: Term): string | null;
+  checkType(term: Term, expected: string): boolean;
+  checkApplication(adj: AdjTerm, noun: NounTerm): { valid: boolean, reason?: string };
+  checkFusion(fusion: FusionTerm): { valid: boolean, result?: number, reason?: string };
+}
+
+// Builder functions
+N(prime: number): NounTerm;
+A(prime: number): AdjTerm;
+FUSE(p: number, q: number, r: number): FusionTerm;
+CHAIN(operators: number[], noun: number): ChainTerm;
+SENTENCE(expr: number | NounTerm): NounSentence;
+SEQ(s1: SentenceTerm, s2: SentenceTerm): SeqSentence;
+IMPL(s1: SentenceTerm, s2: SentenceTerm): ImplSentence;
+```
+
+### Reduction System (`core/reduction.js`)
+
+```typescript
+// Prime-preserving operators
+class PrimeOperator {
+  apply(prime: number): number;
+  isPreserving(): boolean;
+}
+
+class ResonanceOperator extends PrimeOperator {
+  constructor(basePrime: number);
+}
+
+class NextPrimeOperator extends PrimeOperator {}
+class ModularOperator extends PrimeOperator {
+  constructor(modulus: number);
+}
+class IdentityOperator extends PrimeOperator {}
+
+// Reduction system
+class ReductionSystem {
+  addOperator(op: PrimeOperator): void;
+  step(primes: number[]): { result: number[], changed: boolean };
+  normalize(primes: number[]): { normalForm: number[], steps: object[] };
+  evaluate(term: Term): number[];
+}
+
+// Utilities
+class FusionCanonicalizer {
+  canonicalize(fusion: FusionTerm): FusionTerm;
+}
+
+class NormalFormVerifier {
+  isNormalForm(primes: number[]): boolean;
+  verify(primes: number[]): { isNormal: boolean, reason?: string };
+}
+
+// Proof functions
+demonstrateStrongNormalization(primes: number[], system: ReductionSystem): {
+  terminates: boolean;
+  steps: number;
+  trace: object[];
+};
+
+testLocalConfluence(primes: number[], system: ReductionSystem): {
+  confluent: boolean;
+  examples: object[];
+};
+```
+
+### Lambda Translation (`core/lambda.js`)
+
+```typescript
+// Lambda expressions
+class LambdaExpr {}
+class VarExpr extends LambdaExpr {
+  constructor(name: string);
+}
+class ConstExpr extends LambdaExpr {
+  constructor(value: any);
+}
+class LamExpr extends LambdaExpr {
+  constructor(param: string, body: LambdaExpr);
+}
+class AppExpr extends LambdaExpr {
+  constructor(func: LambdaExpr, arg: LambdaExpr);
+}
+class LetExpr extends LambdaExpr {
+  constructor(name: string, value: LambdaExpr, body: LambdaExpr);
+}
+class PairExpr extends LambdaExpr {
+  constructor(first: LambdaExpr, second: LambdaExpr);
+}
+class ProjExpr extends LambdaExpr {
+  constructor(pair: LambdaExpr, index: 1 | 2);
+}
+
+// Translation
+class Translator {
+  translateNoun(noun: NounTerm): LambdaExpr;
+  translateAdj(adj: AdjTerm): LambdaExpr;
+  translateChain(chain: ChainTerm): LambdaExpr;
+  translateFusion(fusion: FusionTerm): LambdaExpr;
+  translateSentence(sentence: SentenceTerm): LambdaExpr;
+  translate(term: Term): LambdaExpr;
+}
+
+// Evaluation
+class LambdaEvaluator {
+  substitute(expr: LambdaExpr, name: string, value: LambdaExpr): LambdaExpr;
+  betaReduce(expr: LambdaExpr): LambdaExpr;
+  normalize(expr: LambdaExpr, maxSteps?: number): LambdaExpr;
+}
+
+// Semantics
+class Semantics {
+  domain: number[];
+  interpret(term: Term): any;
+  satisfies(sentence: SentenceTerm): boolean;
+}
+
+class ConceptInterpreter {
+  define(name: string, meaning: any): void;
+  interpret(name: string): any;
+}
+```
+
+### Enochian Module (`apps/sentient/lib/enochian-vocabulary.js`)
+
+```typescript
+// Alphabet (21 letters)
+const ENOCHIAN_ALPHABET: {
+  [letter: string]: {
+    name: string;
+    prime: number;
+    value: number;
+    angle: number;
+  }
+};
+
+// Prime basis
+const PRIME_BASIS: number[];  // [7, 11, 13, 17, 19, 23, 29]
+
+// Twist operators
+class TwistOperator {
+  constructor(prime: number);
+  angle: number;  // 360/p degrees
+  apply(value: number): number;
+}
+
+function validateTwistClosure(basis: number[]): boolean;
+
+// Words
+class EnochianWord {
+  constructor(word: string);
+  letters: object[];
+  primeValue: number;
+  toString(): string;
+}
+
+// Core vocabulary (35+ words)
+const CORE_VOCABULARY: {
+  [word: string]: {
+    meaning: string;
+    category: string;
+    primeSignature: number[];
+  }
+};
+
+// The Nineteen Calls
+const THE_NINETEEN_CALLS: {
+  [number: string]: {
+    name: string;
+    purpose: string;
+  }
+};
+
+// Sedenion operations
+class SedenionElement {
+  constructor(components: number[]);  // 16 components
+  add(other: SedenionElement): SedenionElement;
+  multiply(other: SedenionElement): SedenionElement;  // Non-commutative!
+  conjugate(): SedenionElement;
+  norm(): number;
+}
+
+// Engine
+class EnochianEngine {
+  parseWord(word: string): EnochianWord;
+  computePrimeValue(word: string): number;
+  getVocabularyEntry(word: string): object | undefined;
+}
+```

package/docs/theory/03-phase-synchronization.md

@@ -346,6 +346,201 @@ This captures how the field **responds to input** rather than just its final sta
 
 ---
 
+## Extended Synchronization Models
+
+Beyond the basic Kuramoto model, TinyAleph provides five advanced synchronization models for complex dynamics:
+
+### NetworkKuramoto - Topology-Aware Coupling
+
+Instead of all-to-all coupling, uses an adjacency matrix A:
+
+```
+dθᵢ/dt = ωᵢ + K Σⱼ Aᵢⱼ sin(θⱼ - θᵢ)
+```
+
+This enables **modular synchronization** that respects semantic neighborhoods:
+
+```javascript
+const { NetworkKuramoto } = require('@aleph-ai/tinyaleph');
+
+// Create with custom adjacency
+const network = new NetworkKuramoto(frequencies, adjacency, 0.5);
+
+// Or build from entanglement graph
+network.setFromEntanglementGraph(entanglementGraph, primeList);
+
+// Find synchronized clusters
+const clusters = network.findClusters(0.5);
+console.log('Found', clusters.length, 'clusters');
+
+// Network metrics
+console.log('Clustering coefficient:', network.averageClustering());
+```
+
+**Semantic Use**: Respects concept neighborhoods from the EntanglementLayer.
+
+---
+
+### AdaptiveKuramoto - Hebbian Plasticity
+
+Coupling strengths evolve based on synchronization:
+
+```
+dθᵢ/dt = ωᵢ + (1/N) Σⱼ Kᵢⱼ sin(θⱼ - θᵢ)
+dKᵢⱼ/dt = ε(cos(θⱼ - θᵢ) - Kᵢⱼ)
+```
+
+**"Concepts that sync together link together"**
+
+```javascript
+const { AdaptiveKuramoto } = require('@aleph-ai/tinyaleph');
+
+// Create with learning rate
+const adaptive = new AdaptiveKuramoto(frequencies, 0.3, 0.02);
+
+// Evolve - coupling strengths change!
+for (let i = 0; i < 1000; i++) {
+  adaptive.tick(0.05);
+}
+
+// Check evolved coupling
+console.log('Total coupling:', adaptive.totalCoupling());
+console.log('K(0,1):', adaptive.adjacency[0][1]); // Strong if synced
+console.log('K(0,7):', adaptive.adjacency[0][7]); // Weak if not synced
+```
+
+**Semantic Use**: Self-organizing semantic memory that learns relationships.
+
+---
+
+### SakaguchiKuramoto - Phase Frustration
+
+Adds a phase lag parameter α that introduces frustration:
+
+```
+dθᵢ/dt = ωᵢ + (K/N) Σⱼ sin(θⱼ - θᵢ - α)
+```
+
+Creates **chimera states**—where some oscillators synchronize while others don't:
+
+```javascript
+const { SakaguchiKuramoto } = require('@aleph-ai/tinyaleph');
+
+// Create with phase lag
+const sakaguchi = new SakaguchiKuramoto(frequencies, 0.5, Math.PI/4);
+
+// Evolve
+for (let i = 0; i < 500; i++) {
+  sakaguchi.tick(0.05);
+}
+
+// Classify state
+console.log('State:', sakaguchi.classifyState());
+// 'synchronized' | 'chimera' | 'partial' | 'incoherent'
+
+// Chimera ratio (fraction synchronized)
+console.log('Chimera ratio:', sakaguchi.chimeraRatio());
+
+// Critical phase lag for chimera formation
+console.log('Critical α:', SakaguchiKuramoto.criticalPhaseLag(0.5));
+```
+
+**Semantic Use**: Models cognitive dissonance, competing interpretations, or partial understanding.
+
+---
+
+### SmallWorldKuramoto - Watts-Strogatz Topology
+
+Creates small-world networks with:
+- **High clustering** (local neighborhoods connected)
+- **Short path length** (random long-range shortcuts)
+
+```javascript
+const { SmallWorldKuramoto } = require('@aleph-ai/tinyaleph');
+
+// k = neighbors per side, p = rewiring probability
+// p=0: ring lattice, p=1: random graph
+const smallWorld = new SmallWorldKuramoto(frequencies, 4, 0.1, 0.5);
+
+// Network metrics
+console.log('Clustering:', smallWorld.averageClustering());
+console.log('Avg path length:', smallWorld.averagePathLength());
+console.log('Small-world σ:', smallWorld.smallWorldCoefficient());
+// σ > 1 indicates small-world properties
+
+// Regenerate with new parameters
+smallWorld.regenerate(6, 0.2);
+```
+
+| Rewiring p | Clustering | Path Length | Character |
+|------------|------------|-------------|-----------|
+| 0.0        | High       | Long        | Regular lattice |
+| 0.1        | High       | Short       | **Small-world** |
+| 1.0        | Low        | Short       | Random |
+
+**Semantic Use**: Balance between local semantic clusters and global conceptual reach.
+
+---
+
+### MultiSystemCoupling - Cross-System Synchronization
+
+Couples multiple Kuramoto systems via their mean fields:
+
+```
+dθᵢ^(a)/dt = [internal coupling] + Σ_b G_ab r^(b) sin(ψ^(b) - θᵢ^(a))
+```
+
+Models multi-agent alignment or hierarchical organization:
+
+```javascript
+const {
+  KuramotoModel,
+  MultiSystemCoupling,
+  createHierarchicalCoupling,
+  createPeerCoupling
+} = require('@aleph-ai/tinyaleph');
+
+// Manual creation
+const system1 = new KuramotoModel(frequencies, 0.4);
+const system2 = new KuramotoModel(frequencies, 0.4);
+const multi = new MultiSystemCoupling([system1, system2]);
+
+// Or use factories
+const hierarchy = createHierarchicalCoupling(frequencies, 3, 16);
+const peers = createPeerCoupling(frequencies, 4, 0.15);
+
+// Evolve
+for (let i = 0; i < 800; i++) {
+  multi.tick(0.05);
+}
+
+// Analyze
+const state = multi.getState();
+console.log('Global order:', state.globalOrder);
+console.log('Inter-system coherence:', state.interSystemCoherence);
+// Matrix showing phase alignment between systems
+```
+
+**Semantic Use**:
+- Hierarchical: context/domain layers driving content layers
+- Peer: multiple agents reaching consensus
+- Cross-domain: knowledge transfer between fields
+
+---
+
+## Model Selection Guide
+
+| Scenario | Model | Why |
+|----------|-------|-----|
+| Semantic neighborhood structure | NetworkKuramoto | Respects topology |
+| Learning relationships | AdaptiveKuramoto | Self-organizing |
+| Conflicting interpretations | SakaguchiKuramoto | Chimera states |
+| Balance local/global | SmallWorldKuramoto | Optimal connectivity |
+| Multi-agent consensus | MultiSystemCoupling | Cross-system |
+| Hierarchical context | MultiSystemCoupling | Bottom-up flow |
+
+---
+
 ## Summary
 
 Phase synchronization provides:
@@ -356,6 +551,7 @@ Phase synchronization provides:
 4. **Transient capture** of input-specific responses
 5. **Adaptive coupling** for stability control
 6. **Field-based computation** where answers emerge from dynamics
+7. **Extended models** for topology, plasticity, frustration, and multi-system dynamics
 
 The oscillator model is the heartbeat of semantic computation.
 

package/docs/theory/README.md

@@ -14,6 +14,10 @@ This section provides a deep exploration of the mathematical and conceptual foun
 8. [The Semantic Sieve](./08-semantic-sieve.md) - Ensuring prime uniqueness
 9. [Temporal Emergence](./09-temporal-emergence.md) - Time as emergent from prime-resonant symbolic computation
 10. [Quaternionic Memory Field](./10-quaternionic-memory.md) - 4D rotational semantics and non-commutative memory
+11. [Formal Type System](./11-formal-types.md) - Typed term calculus N(p)/A(p)/S
+12. [Reduction Semantics](./12-reduction-semantics.md) - Strong normalization and confluence
+13. [Lambda Translation](./13-lambda-translation.md) - Model-theoretic semantics via λ-calculus
+14. [Enochian Language](./14-enochian-language.md) - The 21-letter angelic alphabet
 
 ---
 
@@ -157,6 +161,49 @@ This two-layer architecture explains:
 
 ---
 
+## New: Formal Semantics Layer
+
+Recent additions to Aleph include a rigorous formal semantics layer implementing model-theoretic foundations:
+
+### Typed Term Calculus
+
+The library now supports a formal type system with three primitive types:
+
+| Type | Notation | Interpretation |
+|------|----------|----------------|
+| Noun | N(p) | Prime p as referent: ⟦N(p)⟧ = p |
+| Adjective | A(p) | Partial function f_p with domain constraint p < q |
+| Sentence | S | Discourse state as sequence in D* |
+
+Key features:
+- **Ordering Constraint**: A(p) can only apply to N(q) when p < q
+- **Triadic Fusion**: FUSE(p,q,r) where p+q+r must be prime
+- **Sentence Composition**: Sequential (◦) and implication (⇒) operators
+
+### Reduction Semantics
+
+The reduction system provides:
+- **Small-step reduction**: e → e' via prime-preserving operators ⊕
+- **Strong normalization**: Termination guaranteed by strictly decreasing measure
+- **Confluence**: Via Newman's Lemma on local confluence
+
+### Lambda Translation
+
+Model-theoretic semantics via translation function τ:
+- τ(N(p)) = constant representing p
+- τ(A(p)N(q)) = application (f_p q)
+- τ(FUSE(p,q,r)) = sum constant
+
+### Enochian Language Module
+
+The 21-letter angelic alphabet with mathematical structure:
+- **Prime Basis**: PE = {7, 11, 13, 17, 19, 23, 29}
+- **Twist Angles**: κ(p) = 360/p degrees
+- **Sedenion Operations**: 16-dimensional hypercomplex multiplication
+- **Core Vocabulary**: 35+ traditional Enochian words
+
+---
+
 ## Continue Reading
 
 - [Prime Semantics →](./01-prime-semantics.md)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aleph-ai/tinyaleph",
-  "version": "1.0.2",
+  "version": "1.2.0",
   "description": "Prime-resonant semantic computing framework - hypercomplex algebra, oscillator dynamics, and entropy-minimizing reasoning",
   "main": "index.js",
   "types": "types/index.d.ts",
@@ -94,7 +94,7 @@
   },
   "dependencies": {
     "@noble/curves": "^1.9.7",
-    "@sschepis/resolang": "^0.1.2",
+    "@sschepis/resolang": "^0.4.1",
     "@tensorflow/tfjs-node": "^4.22.0"
   }
 }

package/physics/index.js

@@ -4,26 +4,26 @@
 
 const { Oscillator, OscillatorBank } = require('./oscillator');
 const { KuramotoModel } = require('./kuramoto');
-const { 
-  shannonEntropy, 
-  stateEntropy, 
-  coherence, 
+const {
+  shannonEntropy,
+  stateEntropy,
+  coherence,
   mutualInformation,
   relativeEntropy,
   jointEntropy,
   oscillatorEntropy
 } = require('./entropy');
-const { 
-  estimateLyapunov, 
-  classifyStability, 
+const {
+  estimateLyapunov,
+  classifyStability,
   adaptiveCoupling,
   localLyapunov,
   delayEmbedding,
   stabilityMargin
 } = require('./lyapunov');
-const { 
-  collapseProbability, 
-  shouldCollapse, 
+const {
+  collapseProbability,
+  shouldCollapse,
   measureState,
   collapseToIndex,
   bornMeasurement,
@@ -31,12 +31,78 @@ const {
   applyDecoherence
 } = require('./collapse');
 
+// Extended synchronization models
+const {
+  NetworkKuramoto,
+  AdaptiveKuramoto,
+  SakaguchiKuramoto,
+  SmallWorldKuramoto,
+  MultiSystemCoupling,
+  createHierarchicalCoupling,
+  createPeerCoupling
+} = require('./sync-models');
+
+// Stochastic Kuramoto models
+const {
+  StochasticKuramoto,
+  ColoredNoiseKuramoto,
+  ThermalKuramoto,
+  gaussianRandom
+} = require('./stochastic-kuramoto');
+
+// Primeon Z-Ladder with canonical U evolution
+const {
+  PrimeonZLadderU,
+  createPrimeonLadder,
+  shannonEntropyNats,
+  probsOf,
+  normalize: normalizeComplex,
+  C: Complex
+} = require('./primeon_z_ladder_u');
+
+// Multi-channel Primeon Z-Ladder
+const {
+  ZChannel,
+  PrimeonZLadderMulti,
+  createMultiChannelLadder,
+  createAdiabaticSchedule
+} = require('./primeon_z_ladder_multi');
+
 module.exports = {
   // Oscillators
   Oscillator,
   OscillatorBank,
   KuramotoModel,
   
+  // Extended synchronization models
+  NetworkKuramoto,
+  AdaptiveKuramoto,
+  SakaguchiKuramoto,
+  SmallWorldKuramoto,
+  MultiSystemCoupling,
+  createHierarchicalCoupling,
+  createPeerCoupling,
+  
+  // Stochastic Kuramoto models
+  StochasticKuramoto,
+  ColoredNoiseKuramoto,
+  ThermalKuramoto,
+  gaussianRandom,
+  
+  // Primeon Z-Ladder (canonical U evolution)
+  PrimeonZLadderU,
+  createPrimeonLadder,
+  shannonEntropyNats,
+  probsOf,
+  normalizeComplex,
+  Complex,
+  
+  // Multi-channel Primeon Z-Ladder
+  ZChannel,
+  PrimeonZLadderMulti,
+  createMultiChannelLadder,
+  createAdiabaticSchedule,
+  
   // Entropy & Information
   shannonEntropy,
   stateEntropy,