@aleph-ai/tinyaleph 1.0.2 → 1.1.0

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.1.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,32 @@ const {
   applyDecoherence
 } = require('./collapse');
 
+// Extended synchronization models
+const {
+  NetworkKuramoto,
+  AdaptiveKuramoto,
+  SakaguchiKuramoto,
+  SmallWorldKuramoto,
+  MultiSystemCoupling,
+  createHierarchicalCoupling,
+  createPeerCoupling
+} = require('./sync-models');
+
 module.exports = {
   // Oscillators
   Oscillator,
   OscillatorBank,
   KuramotoModel,
   
+  // Extended synchronization models
+  NetworkKuramoto,
+  AdaptiveKuramoto,
+  SakaguchiKuramoto,
+  SmallWorldKuramoto,
+  MultiSystemCoupling,
+  createHierarchicalCoupling,
+  createPeerCoupling,
+  
   // Entropy & Information
   shannonEntropy,
   stateEntropy,