@aleph-ai/tinyaleph 1.0.0

package/docs/theory/06-two-layer-meaning.md

@@ -0,0 +1,414 @@
+# Two-Layer Meaning
+
+## The Fundamental Distinction
+
+A profound insight underlies Aleph's architecture: **meaning is different from words**.
+
+Consider: we have many words for the same concept:
+- "awesome", "splendid", "magnificent", "fire 🔥", "magnifique"
+
+All different surface forms. All pointing to the same underlying meaning.
+
+This reveals a two-layer structure:
+
+```
+┌────────────────────────────────────────────────────────────┐
+│                    LAYER 1: PRIME SUBSTRATE                 │
+│                                                            │
+│   Universal, pre-linguistic meaning structure               │
+│   Same primes = same meaning, regardless of language        │
+│                                                            │
+│   AWESTRUCK = [2, 5, 11]                                   │
+│   (existence + form + psyche)                              │
+└────────────────────────────────────────────────────────────┘
+                              ↕
+┌────────────────────────────────────────────────────────────┐
+│                    LAYER 2: SURFACE VOCABULARY              │
+│                                                            │
+│   Language-specific, culture-dependent word choice          │
+│   Same primes → different words in different contexts       │
+│                                                            │
+│   [2, 5, 11] → "awesome" (American casual)                 │
+│   [2, 5, 11] → "splendid" (British formal)                 │
+│   [2, 5, 11] → "fire 🔥" (Gen Z slang)                     │
+│   [2, 5, 11] → "magnifique" (French)                       │
+└────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## Layer 1: The Prime Substrate
+
+The prime substrate is **invariant meaning**—what something actually IS.
+
+### Properties
+
+| Property | Description |
+|----------|-------------|
+| **Pre-linguistic** | Exists before words |
+| **Cross-cultural** | Same in every language |
+| **Cross-species** | A dog feels fear too |
+| **Cross-temporal** | Ancient humans felt love |
+| **Invariant** | The meaning doesn't change |
+
+### Example Encoding
+
+```
+AWESTRUCK = [2, 5, 11]
+  2 = existence (something IS)
+  5 = form (impressive structure)
+  11 = psyche (affects the soul)
+  
+→ "that which exists with impressive form affecting the soul"
+```
+
+This prime signature is the **same** regardless of what word you use to express it.
+
+---
+
+## Layer 2: The Surface Vocabulary
+
+The surface layer maps primes to words, with **biases** that depend on context.
+
+### Multiple Words, Same Primes
+
+| Word | Language/Context | Prime Signature |
+|------|-----------------|-----------------|
+| awesome | American casual | [2, 5, 11] |
+| splendid | British formal | [2, 5, 11] |
+| fire 🔥 | Gen Z slang | [2, 5, 11] |
+| magnifique | French | [2, 5, 11] |
+| sugoi | Japanese | [2, 5, 11] |
+| wunderbar | German | [2, 5, 11] |
+
+### Properties
+
+| Property | Description |
+|----------|-------------|
+| **Linguistic** | Requires language |
+| **Cultural** | Varies by community |
+| **Temporal** | Changes over time |
+| **Arbitrary** | Any symbol can map |
+| **Learned** | Acquired through exposure |
+
+---
+
+## The Translation Machine
+
+Translation is NOT: Word₁ → Word₂ (error-prone, loses nuance)
+
+Translation IS: Word₁ → Primes → Word₂ (meaning-preserving)
+
+```javascript
+function translate(word, fromLanguage, toLanguage) {
+  // Go down to prime layer
+  const primes = this.vocabularies[fromLanguage].encode(word);
+  
+  // Come back up in new language
+  return this.vocabularies[toLanguage].decode(primes);
+}
+```
+
+This explains why translation is possible (same primes) and why it's hard (different surface forms).
+
+---
+
+## The TwoLayerEngine
+
+Aleph implements this architecture:
+
+```javascript
+class TwoLayerEngine {
+  constructor(config) {
+    // Layer 1: Core meaning engine
+    this.core = new SemanticBackend(config.core);
+    
+    // Layer 2: Surface word selection
+    this.surfaces = new SurfaceManager();
+    this.biasEngine = new BiasEngine();
+  }
+  
+  process(input, options = {}) {
+    // Layer 1: Extract meaning
+    const tokens = this.core.encodeOrdered(input);
+    const meaningState = this.core.orderedPrimesToState(tokens);
+    
+    // Layer 2: Select words
+    const selectedWords = this.selectWords(tokens, options);
+    
+    return {
+      meaning: meaningState,
+      surface: selectedWords
+    };
+  }
+}
+```
+
+---
+
+## Surface Vocabularies (Registers)
+
+Different registers map the same primes to different words:
+
+### Formal Register
+
+```javascript
+surfaces.create('formal', {
+  vocabulary: {
+    'truth': { primes: [7, 11, 13], bias: 1.0 },
+    'verity': { primes: [7, 11, 13], bias: 0.8 },
+    'veracity': { primes: [7, 11, 13], bias: 0.6 },
+    
+    'wisdom': { primes: [2, 7, 11], bias: 1.0 },
+    'sagacity': { primes: [2, 7, 11], bias: 0.6 },
+    'prudence': { primes: [2, 7, 11], bias: 0.8 },
+  }
+});
+```
+
+### Casual Register
+
+```javascript
+surfaces.create('casual', {
+  vocabulary: {
+    'truth': { primes: [7, 11, 13], bias: 0.5 },
+    'real talk': { primes: [7, 11, 13], bias: 1.0 },
+    'straight up': { primes: [7, 11, 13], bias: 0.8 },
+    'no cap': { primes: [7, 11, 13], bias: 0.6 },
+    
+    'wisdom': { primes: [2, 7, 11], bias: 0.6 },
+    'smarts': { primes: [2, 7, 11], bias: 1.0 },
+    'big brain': { primes: [2, 7, 11], bias: 0.7 },
+  }
+});
+```
+
+### Technical Register
+
+```javascript
+surfaces.create('technical', {
+  vocabulary: {
+    'truth': { primes: [7, 11, 13], bias: 0.8 },
+    'validity': { primes: [7, 11, 13], bias: 1.0 },
+    'accuracy': { primes: [7, 11, 13], bias: 0.9 },
+    
+    'think': { primes: [5, 7, 11], bias: 0.6 },
+    'compute': { primes: [5, 7, 11], bias: 1.0 },
+    'process': { primes: [5, 7, 11], bias: 0.9 },
+  }
+});
+```
+
+---
+
+## Bias-Based Word Selection
+
+Words are selected based on bias weights:
+
+```javascript
+decode(primes, options = {}) {
+  const candidates = [];
+  
+  for (const [word, entry] of this.vocabulary) {
+    // Match primes
+    const match = this.matchScore(primes, entry.primes);
+    if (match < 0.5) continue;
+    
+    // Apply bias
+    let score = match * entry.bias;
+    
+    // Context boost
+    if (options.contexts?.some(c => entry.contexts?.includes(c))) {
+      score *= 1.5;
+    }
+    
+    // Avoid recently used (for variety)
+    if (options.avoid?.includes(word)) {
+      score *= 0.5;
+    }
+    
+    candidates.push({ word, score });
+  }
+  
+  // Select highest-scoring candidate
+  candidates.sort((a, b) => b.score - a.score);
+  return candidates[0]?.word || this.fallback(primes);
+}
+```
+
+---
+
+## Register Translation
+
+Same meaning, different register:
+
+```javascript
+translate(input, fromRegister, toRegister) {
+  // Encode in source register
+  this.surfaces.use(fromRegister);
+  const meaning = this.process(input);
+  
+  // Decode in target register
+  this.surfaces.use(toRegister);
+  const translated = this.selectWords(meaning.tokens);
+  
+  return {
+    original: input,
+    translated: translated.join(' '),
+    meaning: meaning.meaning  // Same meaning!
+  };
+}
+```
+
+### Examples
+
+```
+Formal → Casual:
+  "The verity of the matter is sagacious."
+  → "Real talk, that's big brain."
+  
+Technical → Poetic:
+  "Process the data to compute validity."
+  → "Muse upon the essence to divine the verity."
+  
+Casual → Formal:
+  "That's fire, no cap."
+  → "That is truly magnificent."
+```
+
+---
+
+## Why This Matters
+
+The two-layer model explains:
+
+### Why Translation is Possible
+Same primes → Same meaning → Different words work
+
+### Why Translation is Hard
+Surface forms carry connotations that don't transfer
+
+### Why Poetry Survives Translation
+Prime resonance transcends specific words
+
+### Why Puns Don't Translate
+Puns depend on surface form, not meaning
+
+### Why Babies Learn Meaning Before Words
+They absorb primes first, words second
+
+### Why Music is Universal
+Frequencies are primes, no words needed
+
+---
+
+## Cross-Species Communication
+
+If animals also operate on primes:
+
+```javascript
+const dogVocab = {
+  'wag': [2, 3, 5],       // existence + unity + form → happiness
+  'growl': [5, 7, 23],    // form + boundary + intensity → threat
+  'whine': [3, 11, 19],   // unity + psyche + lack → need
+};
+
+function humanToDog(humanWord) {
+  const primes = humanVocab.encode(humanWord);
+  return dogVocab.findBestMatch(primes);
+}
+
+humanToDog('good boy');  // → wag (same prime signature!)
+```
+
+---
+
+## The Platonic Connection
+
+The prime layer is the **Platonic realm of meaning**.
+
+Words are shadows on the cave wall. Different cultures, languages, and eras cast different shadows. But the object casting the shadow—the prime signature—remains constant.
+
+```
+                    MEANING
+                    (Platonic Form)
+                       ↓
+               ┌───────────────┐
+               │    PRIMES     │
+               │  [2,3,5,7...] │
+               │   universal   │
+               └───────┬───────┘
+                       │
+         ┌─────────────┼─────────────┐
+         ↓             ↓             ↓
+     ┌───────┐    ┌───────┐    ┌───────┐
+     │English│    │Mandarin│   │ Dog   │
+     │ words │    │  汉字   │   │sounds │
+     └───────┘    └───────┘    └───────┘
+         ↓             ↓             ↓
+     spoken       written        barked
+     sound        symbol         sound
+```
+
+---
+
+## Implementation in Aleph
+
+### Backend Architecture
+
+```javascript
+class SemanticBackend {
+  // Layer 1: Universal prime substrate
+  primeSubstrate: {
+    [2]: { essence: 'existence', resonance: 1.0 },
+    [3]: { essence: 'unity', resonance: 1.0 },
+    [5]: { essence: 'form', resonance: 1.0 },
+    // ...
+  }
+  
+  // Layer 2: Cultural vocabulary mappings
+  vocabularies: {
+    'en-US-casual': Map<word, primes>,
+    'en-GB-formal': Map<word, primes>,
+    'fr-FR': Map<word, primes>,
+    'emoji': Map<symbol, primes>,
+    // ...
+  }
+}
+```
+
+### Cross-Cultural Bridging
+
+```javascript
+function findSharedMeaning(culture1Word, culture2Word) {
+  const primes1 = cultures['culture1'].encode(culture1Word);
+  const primes2 = cultures['culture2'].encode(culture2Word);
+  
+  const overlap = intersection(primes1, primes2);
+  
+  return {
+    shared: overlap,               // Common ground
+    unique1: difference(primes1, overlap),  // What culture1 adds
+    unique2: difference(primes2, overlap),  // What culture2 adds
+    compatibility: overlap.length / union(primes1, primes2).length
+  };
+}
+```
+
+---
+
+## Summary
+
+The two-layer model:
+
+1. **Separates meaning from words** — primes are meaning, words are pointers
+2. **Enables translation** — through the prime layer
+3. **Supports registers** — same meaning, different style
+4. **Explains universality** — some concepts transcend culture
+5. **Models acquisition** — primes first, words second
+
+Aleph is a GPS for meaning—it works regardless of which map (language) you're using.
+
+---
+
+## Next: [Resonant Field Interface →](./07-resonant-field-interface.md)