@aleph-ai/tinyaleph 1.0.0

package/docs/theory/09-temporal-emergence.md

@@ -0,0 +1,298 @@
+# Temporal Emergence and PRSC
+
+This document covers Prime-Resonant Symbolic Computation (PRSC), a foundational framework that redefines time as an emergent property of symbolic phase alignment.
+
+## Overview
+
+Traditional computational architectures rely on a global clock to synchronize discrete state transitions, treating time as a linear, externally imposed scalar. PRSC takes a radically different approach: **time emerges from the alignment of prime-indexed oscillators**.
+
+The key insight: even in classical systems, the clock is a periodic oscillator—an underlying resonance mechanism that indexes state propagation. Time is an artifact of periodic phase thresholds, not a fundamental flow.
+
+---
+
+## The PRSC Formalism
+
+### Symbolic Phase Space
+
+In PRSC, symbolic states are represented as phase oscillators indexed by prime numbers. Each prime pᵢ drives an oscillator with frequency:
+
+```
+fᵢ ∝ 1/pᵢ
+```
+
+This ensures **incommensurate periods** and a non-repeating temporal field. Incommensurate frequencies can never perfectly synchronize, creating a rich dynamical landscape.
+
+The global phase state is a vector:
+
+```
+Φ(t) = (Φ₁(t), Φ₂(t), ..., Φₙ(t))
+```
+
+where Φᵢ(t) is the phase of the i-th symbolic subspace.
+
+### The Coherence Function
+
+The coherence function C(t) measures phase alignment across all oscillators:
+
+```
+C(t) = Σᵢ,ⱼ wᵢⱼ · cos(Φᵢ(t) - Φⱼ(t))
+```
+
+where wᵢⱼ are weights reflecting symbolic proximity.
+
+**A temporal event occurs when:**
+
+```
+C(t) ≥ C_threshold
+```
+
+This event defines a "tick" of emergent time, replacing the global clock with a dynamic, symbolic convergence process.
+
+### Visualization
+
+```
+t →
+         ╭──────────────────────────────────────────╮
+Φ₁₃(t)   │  ∿∿∿∿∿∿∿∿∿∿∿∿∿∿∿∿∿∿∿∿∿∿∿∿∿∿∿∿∿∿∿∿∿∿∿∿∿  │
+Φ₁₇(t)   │  ∼∼∼∼∼∼∼∼∼∼∼∼∼∼∼∼∼∼∼∼∼∼∼∼∼∼∼∼∼∼∼∼∼∼∼∼∼∼ │
+Φ₁₉(t)   │  ≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈ │
+         ╰──────────────────────────────────────────╯
+                    ↑           ↑
+              Event 1      Event 2
+              (C > C_th)   (C > C_th)
+```
+
+---
+
+## Entropy and State Collapse
+
+System evolution is governed by an entropy operator combining Hamiltonian dynamics with dissipation:
+
+```
+d/dt |ψ(t)⟩ = Ĥ|ψ(t)⟩ - λ(R̂ - τ_stable)|ψ(t)⟩
+```
+
+where:
+- Ĥ is the Hamiltonian (energy operator)
+- λ controls entropy dissipation
+- R̂ is the resonance operator
+- τ_stable is the stability threshold
+
+### Collapse Probability
+
+The probability of state collapse follows:
+
+```
+P_collapse = 1 - e^(-∫ Ŝ(t) dt)
+```
+
+where:
+```
+Ŝ(t) = S₀ e^(-λt)
+```
+
+This means computation occurs **only when symbolic states achieve sufficient coherence**, mimicking quantum-like collapse in a classical system.
+
+---
+
+## Quaternionic Resonance
+
+For primes p ≡ 1 (mod 12), symbolic states are encoded using Gaussian and Eisenstein factorizations embedded in quaternions:
+
+```
+φₖ = c + ki + jℓ + dk,  where k = j·i
+```
+
+### The Quaternionic Resonance Field
+
+```
+ψ_q(x, t) = N⁻¹ ψ̄_q(x) · exp(iφ(x, t))
+```
+
+A projection operator maps this to a Bloch vector:
+
+```
+Ĉ_q : H_q → ℝ⁴
+Ĉ_q|ψ_q⟩ = (1/‖ψ_q‖²)⟨ψ_q, ξ', ξ'⟩
+```
+
+### Quaternionic Synchronization
+
+Nodes in a distributed system synchronize through phase-locking:
+
+```
+┌─────────────────┐              ┌─────────────────┐
+│     Node 1      │              │     Node 2      │
+│   ψ_q^(1)       │◄────────────►│   ψ_q^(2)       │
+│ q=a+bi+cj+dk    │  Phase-lock  │ q'=a'+b'i+c'j+d'k│
+└─────────────────┘   Δψ_q∈[0,π] └─────────────────┘
+```
+
+Collapse occurs when:
+1. Ŝ(y) < 0.3 (low entropy)
+2. The twist angle is properly aligned
+
+This enhances non-local communication by stabilizing states against noise.
+
+---
+
+## Distributed Holographic Memory
+
+### Local Memory Fields
+
+Each node in a distributed PRSC system maintains a local holographic memory field:
+
+```
+(M)ᵣ = Σ_p∈set F_r α_p^(r) e^(-S_r(x,y)) e^(ipθ_r)
+```
+
+### Global Memory State
+
+The global memory emerges from weighted combination:
+
+```
+(M) = Σᵣ wᵣ(M)ᵣ
+```
+
+### Retrieval Process
+
+1. **Local Resonance**: Apply R̂ᵣ(n) to reconstruct |ψᵣ⟩
+2. **Global Coherence**: Synchronize via:
+   ```
+   C_global(t) = Σᵢ,ᵣ Σ_p∈set Fᵣ cos(φ_p^(r) - φᵢ^(r)) · α_p^(r) α_i^(r)
+   ```
+3. **Quaternionic Synchronization**: Exchange ψ_q^(r) with phase-locking
+
+Successful retrieval occurs when C_global(t) ≥ γ_global.
+
+```
+    ┌──────────┐     ┌──────────┐     ┌──────────┐
+    │  Node 1  │     │  Node 2  │     │  Node 3  │
+    │  (M)₁    │     │  (M)₂    │     │  (M)₃    │
+    └────┬─────┘     └────┬─────┘     └────┬─────┘
+         │                │                │
+         └────────────────┼────────────────┘
+                          │
+                          ▼
+                    ┌──────────┐
+                    │  Global  │
+                    │   (M)    │
+                    └──────────┘
+```
+
+---
+
+## Resonant Instruction Selection
+
+The resonant instruction selection operator projects the symbolic state onto instruction attractors at each temporal event:
+
+```
+Π̂_res : H_M → H_I
+
+I_k = arg max_{I∈H_I} |⟨ψ(t)|I⟩|²  subject to C(t) ≥ τ
+```
+
+This triggers execution based on resonance, enabling:
+- Parallel computation
+- Adaptive instruction selection
+- Content-dependent execution paths
+
+---
+
+## RISA: Resonant Instruction Set Architecture
+
+PRSC is implemented through RISA, which includes:
+
+### Core Instructions
+
+| Instruction | Description |
+|-------------|-------------|
+| `RES p, a, φ` | Initialize prime oscillator with amplitude and phase |
+| `COHERE threshold` | Set coherence threshold for temporal events |
+| `PROJ state` | Project state onto instruction space |
+| `COLLAPSE` | Force state collapse |
+
+### Distributed Operations
+
+| Instruction | Description |
+|-------------|-------------|
+| `SEND_QUAT q, node` | Transmit quaternionic state to node |
+| `RECV_QUAT q, node` | Integrate received quaternionic state |
+| `SYNC_GLOBAL p1, p2, node` | Align phases across nodes |
+
+---
+
+## ResoLang
+
+ResoLang is a programming language for PRSC implementation:
+
+```resolang
+% Define oscillators
+primelet p13 = oscillator(prime=13, amplitude=0.7, phase=1.0);
+primelet p17 = oscillator(prime=17, amplitude=0.5, phase=1.3);
+
+% Quaternionic state
+quatstate q = quaternion(p13, gaussian=(1,2), eisenstein=(3,4));
+
+% Symbolic state
+state s = {p13:0.7, p17:0.5};
+
+% Store and retrieve via resonance
+resonant (threshold=0.8) {
+  store s in memory;
+  retrieve s from global_memory;
+}
+```
+
+---
+
+## Applications
+
+### Symbolic AI
+Context-aware, non-linear reasoning that respects semantic relationships.
+
+### Quantum-like Search
+Probabilistic efficiency through resonance-based exploration.
+
+### Decentralized Identity
+Non-local identity management through quaternionic synchronization.
+
+### Quantum Computing
+Classical analogs for quantum algorithm design and testing.
+
+### Cognitive Modeling
+Modeling attention, time perception, and memory retrieval.
+
+---
+
+## Experimental Predictions
+
+PRSC makes testable predictions:
+
+1. **Non-uniform execution delay**: Increases with symbolic complexity
+2. **Temporal compression**: Dense firing during alignment
+3. **Resonance interference patterns**: Observable in memory fields
+4. **Time symmetry breaking**: Near bifurcation points in phase space
+
+These can be validated via simulations or physical resonator arrays.
+
+---
+
+## Implementation in Aleph
+
+Aleph implements PRSC concepts through:
+
+- **Prime-indexed oscillators** → `physics/oscillator.js`, `physics/kuramoto.js`
+- **Coherence functions** → `physics/entropy.js`
+- **State collapse** → `physics/collapse.js`
+- **Temporal events** → `engine/aleph.js` (transform application on entropy threshold)
+- **Quaternionic states** → `core/hypercomplex.js` (sedenions generalize quaternions)
+
+---
+
+## Related Documents
+
+- [Prime Semantics →](./01-prime-semantics.md)
+- [Phase Synchronization →](./03-phase-synchronization.md)
+- [Entropy and Reasoning →](./04-entropy-reasoning.md)
+- [Quaternionic Memory Field →](./10-quaternionic-memory.md)

package/docs/theory/10-quaternionic-memory.md

@@ -0,0 +1,415 @@
+# Quaternionic Memory Field
+
+This document covers the Quaternionic Memory Field (QMF), a formalism for encoding semantic information as dynamic unit quaternions within a high-dimensional Hilbert space.
+
+## Overview
+
+The Quaternionic Memory Field extends standard complex phase vectors into 4-dimensional hypercomplex space. This enables:
+
+- **Rotational semantics**: Meaning encoded as orientations in 4D space
+- **Non-commutative composition**: Order of operations affects outcome
+- **Smooth interpolation**: Continuous transitions between semantic states
+- **Active memory**: Memory as a resonant field, not static storage
+
+---
+
+## Mathematical Foundation
+
+### Quaternion Definition
+
+The fundamental unit of semantic orientation is the quaternion q ∈ ℍ:
+
+```
+q = w + xi + yj + zk
+```
+
+The basis elements satisfy the Hamilton relations:
+
+```
+i² = j² = k² = ijk = -1
+```
+
+From these, the multiplication rules follow:
+
+```
+ij = k,    jk = i,    ki = j
+ji = -k,   kj = -i,   ik = -j
+```
+
+### Unit Quaternion Constraint
+
+All semantic states are normalized (unit quaternions):
+
+```
+|q| = √(w² + x² + y² + z²) = 1
+```
+
+This ensures semantic operations represent **pure rotations** in 4D space, preserving structural integrity. Unit quaternions form a 3-sphere (S³) embedded in 4D space.
+
+```
+        z(k)
+         │
+         │
+         │
+    ─────┼───── y(j)
+        ╱│
+       ╱ │
+      ╱  │
+    x(i)
+    
+    Unit hypersphere: w² + x² + y² + z² = 1
+```
+
+---
+
+## The Extended Field Space
+
+### Prime-Quaternionic Hilbert Space
+
+Standard holographic memory uses a Prime Hilbert Space (H_prime) with orthogonal basis vectors indexed by primes. The quaternionic extension tensor-products this with the quaternion space:
+
+```
+H_Q = H_prime ⊗ ℍ
+```
+
+A state vector |Ψ⟩ in this field is a superposition of prime modes, where each mode carries a quaternion coefficient:
+
+```
+|Ψ⟩ = Σᵢ qᵢ|pᵢ⟩
+```
+
+where:
+- |pᵢ⟩ is the basis vector for the i-th prime
+- qᵢ is the quaternion encoding the semantic orientation of that mode
+
+---
+
+## The Four Semantic Axes
+
+Unlike standard Euclidean coordinates, quaternion components represent **functional properties** of memory:
+
+| Component | Name | Semantic Role |
+|-----------|------|---------------|
+| **w** (scalar) | Coherence | Stability, "truth" alignment, presence strength |
+| **x** (i-axis) | Security | Boundary integrity, encapsulation, safety |
+| **y** (j-axis) | Performance | Efficiency, speed, optimization |
+| **z** (k-axis) | Usability | Accessibility, interface quality, UX |
+
+```
+        w: Coherence
+             │
+             │
+             │
+    ─────────┼────────── y: Performance
+            ╱│
+           ╱ │
+          ╱  │
+    x: Security     z: Usability
+```
+
+This semantic interpretation means:
+- High w → stable, grounded memory
+- High x → well-protected information
+- High y → efficiently retrievable
+- High z → easily understood
+
+---
+
+## Text-to-Field Encoding
+
+Information is encoded into the field by modulating the quaternion axes using prime-based harmonics:
+
+### Scalar Component (w)
+```
+w = Σₖ cos(2πfₖ · charₖ)
+```
+Modulated by cosine functions to establish base coherence.
+
+### Vector Components (x, y, z)
+```
+x = Σₖ sin(2πfₖ · charₖ) · weight_security
+y = Σₖ sin(2πfₖ · charₖ) · weight_performance  
+z = Σₖ sin(2πfₖ · charₖ) · weight_usability
+```
+Modulated by mixed sine/cosine functions to distribute semantic weight.
+
+The result is a unique "rotational signature" for any text.
+
+---
+
+## Non-Commutative Composition
+
+The composition of two memory states uses the **Hamilton Product**:
+
+```
+q₁ × q₂ = (w₁w₂ - v₁·v₂, w₁v₂ + w₂v₁ + v₁×v₂)
+```
+
+where v₁ = (x₁, y₁, z₁) and v₂ = (x₂, y₂, z₂).
+
+### The Critical Property
+
+**Order matters**. In general:
+
+```
+q₁ × q₂ ≠ q₂ × q₁
+```
+
+The **Commutator** measures this divergence:
+
+```
+[q₁, q₂] = q₁q₂ - q₂q₁
+```
+
+If ‖[q₁, q₂]‖ > ε, the sequence is **order-dependent**.
+
+```
+    q₁ ────────► q₁ × q₂
+         ╲
+          ╲
+           ╲
+    q₂ ─────╲──► q₂ × q₁
+              ╲
+    Different results! (Non-commutative)
+```
+
+### Semantic Implication
+
+This allows the field to distinguish:
+- "Action A then Action B" 
+- vs. "Action B then Action A"
+
+For example:
+- "encrypt then send" ≠ "send then encrypt"
+- "read then write" ≠ "write then read"
+
+---
+
+## Field Operations
+
+### Holographic Superposition
+
+Memories are superposed into the global field via element-wise complex multiplication combined with quaternionic rotation:
+
+```
+Ψ_total = Σᵢ (Φ_keyᵢ ⊛ Φ_dataᵢ) × qᵢ
+```
+
+where:
+- Φ = Complex phase vectors (content)
+- q = Quaternion encoding (semantic orientation)
+- ⊛ = Element-wise interaction
+
+When a new pattern is superposed, it **rotates** the existing quaternion field at that prime index.
+
+### Resonance and Retrieval
+
+Retrieval is a resonance operation. The **Resonance Score** combines structural and semantic alignment:
+
+```
+R = α · Jaccard(Σ_query, Σ_pattern) + β · |q_query · q_pattern|
+```
+
+1. **Prime Signature Similarity (Jaccard)**: Do query and memory share prime factors?
+2. **Semantic Alignment (Dot Product)**: Do they point in the same 4D direction?
+
+---
+
+## Entanglement Mechanics
+
+Two memories become **entangled** when their shared structure exceeds a threshold.
+
+### Entanglement Strength
+
+```
+E(A, B) = ½ · (|Σ_A ∩ Σ_B| / max(|Σ_A|, |Σ_B|) + |q_A · q_B|)
+```
+
+If E ≥ 0.3 (typical threshold), an explicit link forms.
+
+```
+┌──────────────┐                    ┌──────────────┐
+│   Memory A   │◄───────────────────│   Memory B   │
+│              │   Entanglement     │              │
+│   q_A        │   E(A,B) ≥ 0.3     │   q_B        │
+└──────────────┘                    └──────────────┘
+```
+
+### Teleportation
+
+Entanglement enables **teleportation**: accessing Memory B instantaneously when interacting with Memory A. This creates a navigable graph within the field.
+
+---
+
+## Field Stability Metrics
+
+Three metrics ensure the memory field remains useful:
+
+### Entropy (S)
+
+Measures information dispersion across prime modes:
+
+```
+S = -Σ pᵢ log₂(pᵢ) / log₂(N)
+```
+
+| Entropy | Meaning |
+|---------|---------|
+| Low (≈0) | Concentrated, sharp memory |
+| High (≈1) | Diffuse, noisy |
+
+### Coherence (C)
+
+Measures phase alignment:
+
+```
+C = |Σ e^(iθⱼ)| / N
+```
+
+| Coherence | Meaning |
+|-----------|---------|
+| ≈1.0 | Perfectly phase-locked, high confidence |
+| ≈0.0 | Random phases, confusion |
+
+### Lyapunov Stability (λ)
+
+Measures divergence of trajectories over time:
+
+```
+λ = lim_{n→∞} (1/n) Σ ln(|dS_{i+1}/dS_i|)
+```
+
+| λ | Meaning |
+|---|---------|
+| < 0 | Stable, converging to truth |
+| > 0 | Unstable, risk of hallucination |
+
+---
+
+## Interpolation: SLERP
+
+Linear interpolation fails for rotations. To transition smoothly between semantic states q₁ and q₂, use **Spherical Linear Interpolation** (SLERP):
+
+```
+Slerp(q₁, q₂, t) = sin((1-t)Ω)/sin(Ω) · q₁ + sin(tΩ)/sin(Ω) · q₂
+```
+
+where:
+```
+cos(Ω) = q₁ · q₂
+```
+
+```
+        ╭─────────────────╮
+       ╱                   ╲
+      ╱   SLERP path        ╲
+    q₁ ──────────────────── q₂
+      ╲                     ╱
+       ╲   Linear path     ╱
+        ╰─────────────────╯
+        
+    (SLERP traces the shortest path on S³)
+```
+
+This enables smooth "thought transitions" between distinct concepts.
+
+---
+
+## Visualization
+
+To visualize the 4D memory field, use a two-step projection:
+
+### Step 1: Stereographic Projection (4D → 3D)
+
+```
+(x, y, z)_3D = (x, y, z)_4D / (1 - w)
+```
+
+Projects the quaternion onto a 3D hyperplane.
+
+### Step 2: Perspective Projection (3D → 2D)
+
+Standard perspective projection using depth (z) to scale node size, representing semantic "closeness" to the observer.
+
+---
+
+## Key Invariants
+
+For logical consistency, preserve these invariants:
+
+| Invariant | Requirement |
+|-----------|-------------|
+| **Unit Norm** | All quaternions satisfy \|q\| = 1 |
+| **Prime Uniqueness** | Each memory has unique prime signature |
+| **Entropy Bounds** | 0 ≤ S ≤ 1 |
+| **Symmetric Entanglement** | E(A,B) = E(B,A) |
+| **Commutator Sensitivity** | Non-commutative operations respected |
+
+---
+
+## Implementation in Aleph
+
+Aleph implements QMF concepts through:
+
+### Hypercomplex States
+The `SedenionState` class generalizes quaternions to 16 dimensions (sedenions contain quaternions as a subspace):
+
+```javascript
+const { SedenionState } = require('./core/hypercomplex');
+
+// Create quaternion-like state (first 4 components)
+const q = new SedenionState([w, x, y, z, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+```
+
+### Non-Commutative Multiplication
+The `multiply()` method respects non-commutativity:
+
+```javascript
+const q1q2 = q1.multiply(q2);
+const q2q1 = q2.multiply(q1);
+// q1q2 ≠ q2q1 in general
+```
+
+### Field Metrics
+Physics module provides entropy and stability:
+
+```javascript
+const { computeEntropy } = require('./physics/entropy');
+const { lyapunov } = require('./physics/lyapunov');
+
+const entropy = computeEntropy(state);
+const stability = lyapunov(entropyTrajectory);
+```
+
+### Semantic Encoding
+Backend encodes text to quaternionic field:
+
+```javascript
+const backend = new SemanticBackend(config);
+const state = backend.textToOrderedState('secure fast usable');
+// State encodes security, performance, usability orientations
+```
+
+---
+
+## Relation to Other Frameworks
+
+| QMF Concept | Aleph Implementation |
+|-------------|---------------------|
+| Quaternion q | SedenionState (generalized) |
+| Unit norm | `state.normalize()` |
+| Hamilton product | `state.multiply()` |
+| Prime Hilbert space | Prime-indexed oscillators |
+| Coherence C | `state.coherence()` |
+| Entropy S | `computeEntropy()` |
+| Entanglement | Zero-divisor detection |
+| SLERP | Interpolation via progressive collapse |
+
+---
+
+## Related Documents
+
+- [Hypercomplex Algebra →](./02-hypercomplex-algebra.md)
+- [Non-Commutativity →](./05-non-commutativity.md)
+- [Entropy and Reasoning →](./04-entropy-reasoning.md)
+- [Temporal Emergence →](./09-temporal-emergence.md)