@aleph-ai/tinyaleph 1.3.0 → 1.4.1

package/README.md

@@ -25,6 +25,15 @@ A novel computational paradigm that encodes meaning as prime number signatures,
 - **Multi-Z Memory**: Hierarchical memory with fast/slow/permanent channels
 - **Symbolic AI**: 184+ emoji symbols with cultural tags, resonance-enhanced inference
 - **Golden Ratio Resonance**: Harmony measurement using φ ≈ 1.618 ratio detection
+- **Topological Invariants**: 108 invariant (2²×3³), Trefoil complexity, physical constant derivation
+- **Gauge Symmetry**: Standard Model SU(3)×SU(2)×U(1) from 108 factorization
+- **Observer Hierarchy**: Multi-scale observers from quantum to cosmic
+- **Free Energy Dynamics**: Cubic FEP model for consciousness and curiosity
+- **Discrete Dynamics**: Integer sine tables, histogram coherence, tick-based gating
+- **Codebook Tunneling**: 64-attractor SMF codebook for controlled state transitions
+- **Canonical Fusion**: Deterministic FUSE(p,q,r) triad selection
+- **CRT-Homology**: Chinese Remainder Theorem for semantic reconstruction with homology-based consistency detection
+- **Birkhoff Attention**: Doubly-stochastic attention via Sinkhorn-Knopp projection
 
 ## Installation
 
@@ -440,6 +449,195 @@ const Jt = createAdiabaticSchedule(0.1, 0.5, 100, 'sinusoidal');
 const ladder2 = new PrimeonZLadderMulti({ N: 16, Jt });
 ```
 
+### Topological Physics
+
+The 108 Invariant from 108bio.pdf provides deep connections between number theory and physics:
+
+```javascript
+const {
+  TWIST_108,
+  Knot,
+  TREFOIL,
+  PhysicalConstants,
+  GaugeSymmetry,
+  FreeEnergyDynamics,
+  OBSERVER_HIERARCHY
+} = require('@aleph-ai/tinyaleph/core/topology');
+
+// 108 Invariant: 2² × 3³ = 108
+console.log(TWIST_108.value);           // 108
+console.log(TWIST_108.factorization);   // { twos: 2, threes: 3 }
+
+// Twist angle κ(p) = 360°/p
+const twistAngle = TWIST_108.twistAngle(7);  // 51.43°
+
+// Find minimum primes for closed twist (sum to 360°)
+const closingPrimes = TWIST_108.findClosingPrimes(3);
+
+// Trefoil Knot with complexity T = s·c - b + u = 17
+console.log(TREFOIL.strands);      // 1
+console.log(TREFOIL.crossings);    // 3
+console.log(TREFOIL.bridges);      // 2
+console.log(TREFOIL.unknotting);   // 1
+console.log(TREFOIL.complexity);   // 17
+
+// Physical constants from 108 + Trefoil
+console.log(PhysicalConstants.PROTON_ELECTRON_RATIO);  // 1836 (17 × 108)
+console.log(PhysicalConstants.FINE_STRUCTURE_INV);     // 137 (108 + 29)
+console.log(PhysicalConstants.ALPHA);                  // 1/137
+
+// Gauge symmetry from 108 factorization
+const gauge = new GaugeSymmetry();
+console.log(gauge.generators);       // { SU3: 8, SU2: 3, U1: 1 }
+console.log(gauge.totalDimension);   // 12
+console.log(gauge.isStandardModel);  // true
+
+// Free Energy Dynamics (cubic FEP)
+// dψ/dt = αψ + βψ² + γψ³
+const fep = new FreeEnergyDynamics({ alpha: 0.1, beta: -0.3, gamma: 0.2 });
+const energy = fep.freeEnergy(0.5);   // F(ψ)
+const gradient = fep.gradient(0.5);   // dF/dψ
+const minima = fep.findMinima();      // Stable states
+
+// Observer Hierarchy (quantum to cosmic scales)
+OBSERVER_HIERARCHY.forEach(level => {
+  console.log(`${level.name}: scale=${level.scale}, capacity=${level.capacity}`);
+});
+// cellular: scale=1e-6, capacity=1e6
+// neural: scale=1e-3, capacity=1e9
+// cognitive: scale=1, capacity=1e12
+// collective: scale=1e6, capacity=1e15
+// cosmic: scale=1e26, capacity=1e21
+```
+
+### Discrete Dynamics
+
+Integer-domain computation from discrete.pdf:
+
+```javascript
+const { INT_SINE_TABLE, computeHistogramCoherence } = require('@aleph-ai/tinyaleph/apps/sentient/lib/prsc');
+const { SMF_CODEBOOK, nearestCodebookAttractor, codebookTunnel } = require('@aleph-ai/tinyaleph/apps/sentient/lib/smf');
+const { canonicalTriad, canonicalFusion, verifyCanonical } = require('@aleph-ai/tinyaleph/apps/sentient/lib/prime-calculus');
+const { TickGate } = require('@aleph-ai/tinyaleph/apps/sentient/lib/hqe');
+
+// Integer Sine Table (M=256 discretization)
+console.log(INT_SINE_TABLE.M);            // 256
+const sinValue = INT_SINE_TABLE.sin(64);  // Integer sine at phase 64
+const cosValue = INT_SINE_TABLE.cos(128); // Integer cosine at phase 128
+
+// Histogram Coherence C_bin(t) = max_k(b_k(t))/|P|
+const phases = [10, 12, 11, 50, 52, 51, 100, 102, 101];
+const coherence = computeHistogramCoherence(phases, { numBins: 16 });
+// coherence ≈ 0.33 (three clusters of 3 phases each)
+
+// 64-Attractor SMF Codebook
+console.log(SMF_CODEBOOK.length);         // 64
+console.log(SMF_CODEBOOK[0]);             // { index: 0, phase: 0, label: '0x00' }
+
+// Find nearest codebook attractor
+const nearest = nearestCodebookAttractor(130);  // phase 130
+console.log(nearest.index);               // Nearest codebook index
+console.log(nearest.distance);            // Distance to attractor
+
+// Controlled tunneling to codebook attractor
+const tunneled = codebookTunnel(130, { force: 0.5 });
+console.log(tunneled.original);           // 130
+console.log(tunneled.target);             // Nearest attractor phase
+console.log(tunneled.result);             // Tunneled phase (interpolated)
+
+// Canonical Fusion FUSE(p,q,r) selection
+const triad = canonicalTriad(19);  // Find canonical triad for sum 19
+console.log(triad);                // [3, 5, 11] (lexicographically first)
+
+// Verify canonical property
+console.log(verifyCanonical(3, 5, 11, 19));  // true
+
+// Fuse with automatic triad selection
+const fused = canonicalFusion(19);
+console.log(fused.triad);          // [3, 5, 11]
+console.log(fused.sum);            // 19
+
+// Tick-Only HQE Gate
+const tickGate = new TickGate({ threshold: 0.7 });
+const gateResult = tickGate.evaluate({ coherence: 0.8, tickValid: true });
+console.log(gateResult.passed);    // true (coherence > threshold && tick valid)
+console.log(gateResult.reason);    // 'TICK_VALID'
+```
+
+### Observer Capacity
+
+Calculate observer capacity from 108bio.pdf's C_obs = α·N_osc·K̄·τ⁻¹:
+
+```javascript
+const { SymbolicObserver } = require('@aleph-ai/tinyaleph/apps/sentient/lib/symbolic-observer');
+
+const observer = new SymbolicObserver();
+
+// Add oscillator bank for N_osc
+observer.addOscillatorBank(bank);
+
+// Calculate observer capacity
+const capacity = observer.calculateObserverCapacity({
+  alpha: 1/137,           // Fine structure constant
+  meanCoupling: 0.5,      // K̄ average coupling
+  coherenceTime: 0.1      // τ coherence time
+});
+
+console.log(capacity.value);       // Capacity in bits/second
+console.log(capacity.numOscillators);
+console.log(capacity.formula);     // 'α × N_osc × K̄ × τ⁻¹'
+```
+
+### Free Energy Curiosity
+
+Cubic FEP-based curiosity for learning systems:
+
+```javascript
+const { FreeEnergyCuriosity } = require('@aleph-ai/tinyaleph/apps/sentient/lib/learning/curiosity');
+
+const curiosity = new FreeEnergyCuriosity({
+  alpha: 0.1,    // Linear coefficient
+  beta: -0.3,    // Quadratic coefficient
+  gamma: 0.2     // Cubic coefficient
+});
+
+// Evaluate free energy at belief state ψ
+const energy = curiosity.freeEnergy(0.5);
+
+// Get gradient for belief update
+const grad = curiosity.gradient(0.5);
+
+// Find stable belief states (local minima)
+const stableStates = curiosity.findMinima();
+
+// Check if current state is at equilibrium
+const isStable = curiosity.isStable(0.5, { tolerance: 0.01 });
+```
+
+### Observer Scale Management
+
+Multi-scale observer hierarchy from 108bio.pdf:
+
+```javascript
+const { ObserverScaleManager } = require('@aleph-ai/tinyaleph/apps/sentient/lib/collective');
+
+const manager = new ObserverScaleManager();
+
+// Assign node to appropriate hierarchy level based on capacity
+const level = manager.assignNode(nodeId, observerCapacity);
+console.log(level.name);       // 'neural', 'cognitive', etc.
+console.log(level.scale);      // Physical scale
+console.log(level.capacity);   // Information capacity
+
+// Get all nodes at a level
+const cognitiveNodes = manager.getNodesAtLevel('cognitive');
+
+// Get hierarchy statistics
+const stats = manager.getHierarchyStats();
+console.log(stats.totalNodes);
+console.log(stats.levelDistribution);
+```
+
 ### ResoFormer Architecture
 
 Complete prime-indexed transformer:
@@ -475,6 +673,105 @@ const model = new ResoFormer({
 const outputs = model.forward([state1, state2]);
 ```
 
+### CRT-Enhanced ResoFormer
+
+Integrates Chinese Remainder Theorem reconstruction with homology-based regularization:
+
+```javascript
+const {
+    CRTResonantAttention,
+    HomologyRegularizedBlock,
+    CRTResoFormer,
+    createCRTResoFormer
+} = require('@aleph-ai/tinyaleph');
+
+// Create CRT-enhanced model
+const model = createCRTResoFormer({
+    numLayers: 3,
+    numHeads: 4,        // Maps to coprime moduli [2, 3, 5, 7]
+    homologyWeight: 0.1
+});
+
+// Process sequence with homology detection
+const sequence = [
+    SparsePrimeState.fromHash('the'),
+    SparsePrimeState.fromHash('quick'),
+    SparsePrimeState.fromHash('fox')
+];
+
+const result = model.forward(sequence);
+
+console.log('Total homology loss:', result.totalLoss);
+console.log('Holes detected:', result.homologyReport.hasHoles);
+console.log('Betti numbers:', result.homologyReport.maxBettiNumber);
+```
+
+### CRT Residue Encoding
+
+Encode semantic states as residue distributions over coprime moduli:
+
+```javascript
+const {
+    ResidueEncoder,
+    CRTReconstructor,
+    BirkhoffProjector,
+    HomologyLoss,
+    DEFAULT_PRIMES_SMALL
+} = require('@aleph-ai/tinyaleph');
+
+// Use first 4 primes: [2, 3, 5, 7], P = 210
+const primes = DEFAULT_PRIMES_SMALL;
+const encoder = new ResidueEncoder(primes, 16);
+const crt = new CRTReconstructor(primes);
+
+// Encode hidden vector to residue distributions
+const h = new Float64Array(16).fill(0.5);
+const residues = encoder.encode(h);
+const expectedResidues = encoder.expectedResidues(residues);
+
+// CRT reconstruction
+const L = crt.reconstruct(expectedResidues);
+console.log('Reconstructed:', L);
+
+// Detect kernel (consistency failures)
+const inKernel = crt.detectKernel(expectedResidues, 0.1);
+console.log('In kernel:', inKernel);
+
+// Birkhoff attention (doubly-stochastic)
+const birkhoff = new BirkhoffProjector(20);
+const attentionMatrix = [[0.8, 0.2], [0.3, 0.7]];
+const projected = birkhoff.project(attentionMatrix);
+// Row sums ≈ 1, column sums ≈ 1
+```
+
+### Homology Loss
+
+Detect semantic inconsistencies as topological holes:
+
+```javascript
+const { HomologyLoss, CRTReconstructor } = require('@aleph-ai/tinyaleph');
+
+const crt = new CRTReconstructor([2, 3, 5, 7]);
+const homology = new HomologyLoss({ tau: 0.1 });
+
+// Batch of residue tuples
+const residueBatch = [
+    [0.5, 1.2, 2.8, 4.1],
+    [0.99, 0.01, 2.5, 3.99],
+    [0.1, 0.2, 0.3, 0.4]
+];
+
+// Compute homology loss
+const result = homology.compute(residueBatch, crt);
+console.log('Homology loss:', result.loss);
+console.log('Cycles detected:', result.cycles);
+
+// Betti numbers (topological invariants)
+const betti = homology.computeBettiNumbers(residueBatch, crt);
+console.log('β₀ (components):', betti.beta0);
+console.log('β₁ (holes):', betti.beta1);
+```
+
 ## Symbolic AI
 
 ### Symbol Database
@@ -723,6 +1020,79 @@ console.log(CORE_VOCABULARY['ZORGE']);  // "be friendly unto"
 | `hash(input)` | Quick semantic hash |
 | `deriveKey(pass, salt)` | Quick key derivation |
 
+### Observer Exports
+
+The observer module provides components for building sentient observer systems:
+
+```javascript
+const observer = require('@aleph-ai/tinyaleph/observer');
+// Or destructure specific exports:
+const {
+    SedenionMemoryField,
+    PRSCLayer,
+    TemporalLayer,
+    SymbolicSMF,
+    SymbolicTemporalLayer,
+    AssaySuite
+} = require('@aleph-ai/tinyaleph/observer');
+```
+
+| Export | Description |
+|--------|-------------|
+| `PrimeOscillator` | Single prime-indexed oscillator |
+| `PRSCLayer` | Prime Resonance Semantic Coherence oscillator bank |
+| `coherenceKernel` | Phase coherence calculation |
+| `TickGate` | Tick-based activation gating |
+| `HQE` | Holographic Quaternion Engine |
+| `SedenionMemoryField` | 16D semantic orientation field |
+| `SMF_AXES` | Named axes for 16D space |
+| `Moment` | Discrete temporal moment |
+| `TemporalLayer` | Moment classification and time tracking |
+| `AttentionFocus` | Attention target with decay |
+| `Goal` | Goal representation with progress |
+| `AgencyLayer` | Goals, attention, and intention management |
+| `BoundaryLayer` | Self-other differentiation |
+| `EntanglementLayer` | Semantic phrase coherence |
+| `SafetyMonitor` | Constraint monitoring |
+| `SymbolicSMF` | Symbol-grounded Sedenion field |
+| `SMFSymbolMapper` | Maps SMF axes to symbols |
+| `AXIS_SYMBOL_MAPPING` | 16 axes → symbol mappings |
+| `SymbolicMoment` | Moment with I-Ching classification |
+| `SymbolicTemporalLayer` | 64-attractor hexagram classification |
+| `HEXAGRAM_ARCHETYPES` | 64 hexagram → archetype mappings |
+| `SymbolicPatternDetector` | Narrative pattern detection |
+| `TimeDilationAssay` | Assay A: Time dilation test |
+| `MemoryContinuityAssay` | Assay B: Memory continuity test |
+| `AgencyConstraintAssay` | Assay C: Agency under constraint test |
+| `NonCommutativeMeaningAssay` | Assay D: Non-commutative meaning test |
+| `AssaySuite` | Run all four validation assays |
+
+### Topology Exports
+
+| Export | Description |
+|--------|-------------|
+| `TWIST_108` | 108 invariant with twist angle calculations |
+| `Knot` | General knot class with invariant computation |
+| `TREFOIL` | Pre-configured trefoil knot (T=17) |
+| `PhysicalConstants` | Derived constants (α, proton/electron ratio) |
+| `GaugeSymmetry` | Standard Model gauge group from 108 |
+| `FreeEnergyDynamics` | Cubic FEP model dψ/dt = αψ + βψ² + γψ³ |
+| `OBSERVER_HIERARCHY` | 5-level observer scale hierarchy |
+
+### Discrete Dynamics Exports
+
+| Export | Description |
+|--------|-------------|
+| `INT_SINE_TABLE` | M=256 integer sine/cosine table |
+| `computeHistogramCoherence` | C_bin(t) = max_k(b_k)/\|P\| |
+| `SMF_CODEBOOK` | 64-attractor codebook array |
+| `nearestCodebookAttractor` | Find nearest attractor for phase |
+| `codebookTunnel` | Controlled tunneling to attractor |
+| `canonicalTriad` | Find lexicographically first triad for sum |
+| `canonicalFusion` | FUSE(p,q,r) with automatic triad |
+| `verifyCanonical` | Verify triad is canonical |
+| `TickGate` | Tick-only HQE gating class |
+
 ### Formal Semantics Exports
 
 | Export | Description |
@@ -783,6 +1153,14 @@ const engine = require('@aleph-ai/tinyaleph/engine');
 | `PrimeLayerNorm` | Prime-preserving normalization |
 | `PositionalPrimeEncoding` | Position as prime phases |
 | `SparsePrimeState` | Sparse activation storage |
+| `CRTResonantAttention` | Multi-head CRT-fused attention |
+| `HomologyRegularizedBlock` | Block with homology loss |
+| `CRTResoFormer` | Complete CRT-enhanced model |
+| `ResidueEncoder` | Encode to residue distributions |
+| `CRTReconstructor` | Chinese Remainder Theorem |
+| `BirkhoffProjector` | Doubly-stochastic projection |
+| `HomologyLoss` | Cycle-based regularization |
+| `CoprimeSelector` | Optimal moduli selection |
 
 ## Documentation
 
@@ -798,7 +1176,22 @@ Full documentation is available in the `docs/` directory:
   
 - **[Reference](./docs/reference/README.md)**: Complete API documentation
   - Core module, physics module, backends, engine
+  - [Topology module](./docs/reference/07-topology.md): 108 invariant, knots, gauge symmetry
   
+- **[CRT-Homology Reference](./docs/reference/09-crt-homology.md)**: CRT reconstruction and homology
+  
+- **[Topology Examples](./examples/topology/README.md)**: 108 invariant and physical constants
+  - 108 invariant and twist angles
+  - Trefoil complexity and mass ratios
+  - Gauge symmetry from factorization
+  - Free energy dynamics
+
+- **[Discrete Dynamics Examples](./examples/discrete/README.md)**: Integer-domain computation
+  - Integer sine tables
+  - Codebook tunneling
+  - Canonical fusion selection
+  - Tick-based gating
+
 - **[Formal Semantics Examples](./examples/formal-semantics/README.md)**: New formal system demos
   - Typed terms and type checking
   - Reduction and normalization
@@ -828,6 +1221,24 @@ node examples/formal-semantics/02-reduction.js
 node examples/formal-semantics/03-lambda-translation.js
 node examples/formal-semantics/04-enochian-language.js
 
+# Topology examples (108 invariant, physical constants)
+node examples/topology/01-108-invariant.js
+node examples/topology/02-trefoil-constants.js
+node examples/topology/03-gauge-symmetry.js
+node examples/topology/04-free-energy-dynamics.js
+
+# Discrete dynamics examples (integer tables, codebooks)
+node examples/discrete/01-integer-sine-table.js
+node examples/discrete/02-codebook-tunneling.js
+node examples/discrete/03-canonical-fusion.js
+node examples/discrete/04-tick-gate.js
+
+# CRT-Homology examples
+node examples/crt-homology/01-residue-encoding.js
+node examples/crt-homology/02-birkhoff-attention.js
+node examples/crt-homology/03-homology-loss.js
+node examples/crt-homology/04-crt-resoformer.js
+
 # Bioinformatics examples
 node examples/bioinformatics/01-dna-encoding.js
 node examples/bioinformatics/02-central-dogma.js
@@ -847,10 +1258,10 @@ node examples/08-compound-symbols.js
 ```
 ┌─────────────────────────────────────────────────────────────────┐
 │                        AlephEngine                              │
-│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────────┐ │
-│  │ Oscillators │◄─┤   Field     │◄─┤      Transform          │ │
-│  │  (Kuramoto) │  │  (Sedenion) │  │      Pipeline           │ │
-│  └─────────────┘  └─────────────┘  └─────────────────────────┘ │
+│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────────┐  │
+│  │ Oscillators │◄─┤   Field     │◄─┤      Transform          │  │
+│  │  (Kuramoto) │  │  (Sedenion) │  │      Pipeline           │  │
+│  └─────────────┘  └─────────────┘  └─────────────────────────┘  │
 └─────────────────────────────────────────────────────────────────┘
                               │
          ┌────────────────────┼────────────────────┐
@@ -864,7 +1275,7 @@ node examples/08-compound-symbols.js
 └─────────────────┘ └─────────────────┘ └─────────────────┘
 
 ┌─────────────────────────────────────────────────────────────────┐
-│                     Formal Semantics Layer                       │
+│                     Formal Semantics Layer                      │
 ├─────────────────┬─────────────────┬─────────────────────────────┤
 │   Type System   │   Reduction     │   Lambda Translation        │
 │                 │                 │                             │
@@ -875,7 +1286,7 @@ node examples/08-compound-symbols.js
 └─────────────────┴─────────────────┴─────────────────────────────┘
 
 ┌─────────────────────────────────────────────────────────────────┐
-│                      Symbolic AI Layer                           │
+│                      Symbolic AI Layer                          │
 ├─────────────────┬─────────────────┬─────────────────────────────┤
 │  Symbol DB      │  Inference      │   Resonance                 │
 │                 │                 │                             │
@@ -886,14 +1297,14 @@ node examples/08-compound-symbols.js
 └─────────────────┴─────────────────┴─────────────────────────────┘
 
 ┌─────────────────────────────────────────────────────────────────┐
-│                     Enochian Language Module                     │
+│                     Enochian Language Module                    │
 ├─────────────────────────────────────────────────────────────────┤
-│ • 21-letter alphabet with prime mappings                         │
+│ • 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)                   │
+│ • Twist angles κ(p) = 360/p degrees                             │
+│ • 16-dimensional sedenion operations                            │
+│ • Core vocabulary (35+ words)                                   │
+│ • The Nineteen Calls (traditional invocations)                  │
 └─────────────────────────────────────────────────────────────────┘
 ```