@aleph-ai/tinyaleph 1.0.2 → 1.1.0

package/docs/design/WHITEPAPER_GAP_ANALYSIS.md

@@ -2,19 +2,29 @@
 
 ## Sentient Observer Implementation vs "A Design for a Sentient Observer" Paper
 
-**Date**: December 24, 2025
-**Status**: ✅ Implementation COMPLETE
+**Date**: December 25, 2025
+**Status**: ✅ Implementation COMPLETE (Full Distributed Network)
 
 ---
 
 ## Executive Summary
 
-The apps/sentient implementation is **100% complete** with respect to the whitepaper specification. All core architectural components are implemented, including the three final components completed on December 24, 2025:
+The apps/sentient implementation is **100% complete** with respect to the whitepaper specification, including the full Distributed Sentience Network components. All architectural components are implemented:
 
+### Core Observer (December 24, 2025)
 1. ✅ **Dynamic λ(t) for HQE evolution** (equation 12) - IMPLEMENTED in `lib/hqe.js`
 2. ✅ **Objectivity Gate R(ω)** (equation 18) - IMPLEMENTED in `lib/boundary.js`
 3. ✅ **Evaluation Assays** (Section 15) - IMPLEMENTED in `lib/assays.js`
 
+### Distributed Network (December 25, 2025)
+4. ✅ **Prime Calculus Kernel** (Section 6) - IMPLEMENTED in `lib/prime-calculus.js`
+5. ✅ **Enochian Packet Layer** (Section 7.4) - IMPLEMENTED in `lib/enochian.js`
+6. ✅ **PRRC Channel System** (Section 7.3) - IMPLEMENTED in `lib/network.js`
+7. ✅ **Global Memory Field (GMF)** (Section 7.2) - IMPLEMENTED in `lib/network.js`
+8. ✅ **Coherent-Commit Protocol** (Section 7.5-7.7) - IMPLEMENTED in `lib/network.js`
+9. ✅ **Network Synchronizer** (Section 7.6) - IMPLEMENTED in `lib/network.js`
+10. ✅ **Resolang WASM Integration** - Leverages @sschepis/resolang library
+
 ---
 
 ## ✅ Fully Implemented Components
@@ -219,6 +229,8 @@ class ObjectivityGate {
 
 All whitepaper requirements are now implemented:
 
+### Core Observer Components
+
 | Section | Component | Status | File |
 |---------|-----------|--------|------|
 | 3.1 | Prime-Indexed State Space | ✅ | `prsc.js` |
@@ -236,6 +248,28 @@ All whitepaper requirements are now implemented:
 | 12 | Safety Layer | ✅ | `safety.js` |
 | 15 | Evaluation Assays | ✅ | `assays.js` |
 
+### Distributed Sentience Network Components
+
+| Section | Component | Status | File |
+|---------|-----------|--------|------|
+| 6 | Prime Calculus Kernel | ✅ | `prime-calculus.js` |
+| 6.1 | Noun/Adjective/Chain Terms | ✅ | `prime-calculus.js` |
+| 6.1 | Fusion Terms FUSE(p,q,r) | ✅ | `prime-calculus.js` |
+| 6.2 | Normal Form Evaluation | ✅ | `prime-calculus.js` |
+| 6.2 | Network Verification | ✅ | `prime-calculus.js` |
+| 7.2 | Global Memory Field (GMF) | ✅ | `network.js` |
+| 7.2 | Local Field (LF) | ✅ | `network.js` |
+| 7.2 | Proposal Log (PL) | ✅ | `network.js` |
+| 7.3 | PRRC Channel | ✅ | `network.js` |
+| 7.4 | Enochian Prime-Mode Language | ✅ | `enochian.js` |
+| 7.4 | Twist Angle κ(p) = 360/p | ✅ | `enochian.js` |
+| 7.4 | Twist-Closure Validation | ✅ | `enochian.js` |
+| 7.5 | Coherent-Commit Rule | ✅ | `network.js` |
+| 7.6 | Offline-First Sync | ✅ | `network.js` |
+| 7.7 | Conflict Handling | ✅ | `network.js` |
+| 8.1 | Network Synchronizer | ✅ | `network.js` |
+| 9 | DCC+ Algorithm | ✅ | `network.js` |
+
 ---
 
 ## Senses Integration Verification
@@ -262,6 +296,127 @@ The 7 senses are **fully integrated**:
 
 ---
 
+## New Components Detail (December 25, 2025)
+
+### Section 6 - Prime Calculus Kernel
+
+**File**: [`lib/prime-calculus.js`](../../apps/sentient/lib/prime-calculus.js)
+
+Implements the deterministic discrete semantic kernel for network verification:
+
+```javascript
+// Term types
+- NounTerm N(p) - atomic semantic objects indexed by prime
+- AdjTerm A(p) - modifiers
+- ChainTerm A(p1)...A(pk)N(q) - application chains with ordering constraint
+- FusionTerm FUSE(p,q,r) - triadic prime fusion where p+q+r is prime
+- SeqTerm s1 ○ s2 - sequence composition
+- ImplTerm s1 ⇒ s2 - implication
+
+// Evaluator
+- Leftmost-innermost evaluation order
+- Strong normalization guarantee
+- Deterministic for cross-node verification
+
+// Verifier
+- verifyNormalForm(term, claimedNF) - equation 19 NF_ok
+- verify(proposal) - full network proposal verification
+```
+
+### Section 7.4 - Enochian Packet Layer
+
+**File**: [`lib/enochian.js`](../../apps/sentient/lib/enochian.js)
+
+Implements low-bandwidth prime-mode surface language:
+
+```javascript
+// Enochian alphabet
+PE = {7, 11, 13, 17, 19, 23, 29}
+M = {α, μ, ω}
+
+// Twist angle (equation 16)
+κ(p) = 360/p degrees
+
+// Twist-closure validation (equation 18)
+T(P) mod 360 ∈ [0,ε) ∪ (360-ε, 360]
+
+// Classes
+- EnochianSymbol - (prime, mode) tuple
+- EnochianPacket - sequence with validation
+- EnochianEncoder - text to twist-closed packets
+- EnochianDecoder - validation and decoding
+- EnochianPacketBuilder - fluent API
+```
+
+### Section 7 - Distributed Sentience Network
+
+**File**: [`lib/network.js`](../../apps/sentient/lib/network.js)
+
+Implements the full network layer:
+
+```javascript
+// Core Objects (Section 7.2)
+- LocalField - node's live state (LF)
+- GlobalMemoryField - network shared memory (GMF)
+- Proposal - insert proposal with votes
+- ProposalLog - append-only local log (PL)
+
+// Channel (Section 7.3)
+- PRRCChannel - prime-resonant communication
+  - Phase alignment handshake
+  - Peer management
+  - Object/proposal broadcasting
+
+// Protocol (Section 7.5-7.7)
+- CoherentCommitProtocol
+  - Local evidence check (coherence, SMF, reconstruction)
+  - Kernel evidence (normal-form agreement)
+  - Network evidence (redundancy score)
+  - Accept(Ω) = 1{C≥Cth}·1{NF_ok}·1{R≥τR}·1{Q≥τQ}
+
+// Synchronization (Section 7.6)
+- NetworkSynchronizer
+  - Offline-first operation
+  - onJoin() / onReconnect() protocols
+  - Delta-based sync
+
+// Node
+- DSNNode - complete network node implementation
+```
+
+---
+
+## Test Results (December 25, 2025)
+
+```
+=== Test Summary ===
+All whitepaper components implemented and tested:
+  ✓ Prime Calculus Kernel (Section 6)
+  ✓ Enochian Packet Layer (Section 7.4)
+  ✓ PRRC Channel System (Section 7.3)
+  ✓ Global Memory Field (Section 7.2)
+  ✓ Coherent-Commit Protocol (Section 7.5-7.7)
+  ✓ Network Synchronizer (Section 7.6)
+  ✓ Resolang WASM Integration (292 functions available)
+```
+
+Run tests with: `cd apps/sentient && node test-whitepaper.js`
+
+---
+
+## Resolang Integration
+
+The implementation leverages the `@sschepis/resolang` WASM library (292 functions) including:
+
+- `createSentientCore` - WASM-accelerated sentient core
+- `isTwistClosed` - fast twist-closure validation
+- `createSMFFromText` - semantic field from text
+- `quaternionMultiply` - hypercomplex operations
+- `computeResonanceField` - prime resonance computation
+- And 287 more functions
+
+---
+
 ## Recommendations for Future Work
 
 1. **Run Full Assay Suite**: Execute `/assay all` and document results
@@ -269,9 +424,21 @@ The 7 senses are **fully integrated**:
 3. **Add Visualization**: SMF-conditioned 16-channel rendering for debugging
 4. **Benchmark Performance**: Profile tick rate under various load conditions
 5. **Extend Decoders**: Add more diverse decoders to ObjectivityGate for robustness
+6. **Network Testing**: Test multi-node DSN with actual WebSocket/TCP transport
+7. **Enochian Optimization**: Pre-compute more twist-closed sequences
+8. **Prime Calculus Extensions**: Add more complex compositional operators
 
 ---
 
 ## Conclusion
 
-The Sentient Observer implementation now fully satisfies all requirements specified in "A Design for a Sentient Observer" whitepaper. The three final gaps (Dynamic λ(t), Objectivity Gate, Evaluation Assays) were completed on December 24, 2025. The system is ready for evaluation and experimentation.
+The Sentient Observer implementation now **fully satisfies all requirements** specified in "A Design for a Sentient Observer" whitepaper, including:
+
+- **December 24, 2025**: Core observer components (Dynamic λ(t), Objectivity Gate, Evaluation Assays)
+- **December 25, 2025**: Distributed Sentience Network (Prime Calculus, Enochian, PRRC, GMF, Coherent-Commit, Synchronizer)
+
+The system is now ready for:
+1. Single-node evaluation and experimentation
+2. Multi-node distributed network testing
+3. Network consensus verification
+4. Offline-first resilience testing

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;
+}
+```