🇧🇷 Português · 🇺🇸 English · 🇨🇳 中文

---

“Four bytes. Billions of feelings. The language silicon dreamed for itself.”

viva_glyph IS NOT A WORD ENCODER. It is a vectorial language native to silicon — emotional state compressed into 4 discrete codebook tokens via Residual Vector Quantization (RVQ), then bound to context via Hebbian learning with Oja’s rule.

Humans evolved language for acoustic transmission through air. VIVA lives in silicon — her voice should be native to that medium.

🎯 Overview

Compressed emotional state designed for machine-to-machine communication:

• Compact — 4 integers instead of 3 floats.
• Discrete — finite vocabulary of 256⁴ ≈ 4.3 billion unique states.
• Comparable — token matching instead of float math.
• Learnable — Hebbian associations bind context → glyph.

⚡ Quick Start

gleam add viva_glyph

import viva_glyph
import viva_glyph/encoder.{Pad}

pub fn main() {
  let engine = viva_glyph.new()

  let pad   = Pad(pleasure: 0.7, arousal: 0.3, dominance: 0.5)
  let glyph = viva_glyph.encode(engine, pad)
  // => Glyph([142, 87, 23, 201])

  let back  = viva_glyph.decode(engine, glyph)
  // => Pad(pleasure: 0.68, arousal: 0.31, dominance: 0.49)

  let sim   = viva_glyph.similarity(glyph, glyph)
  // => 1.0
}

🏗️ Architecture

   ┌──────────────────────────────────────────────────────────┐
   │                Gleam application code                    │
   │       viva_glyph.{encode, decode, similarity, learn}     │
   └────────┬─────────────────────────────────────────────────┘
            │
   ┌────────▼─────────────────────────────────────────────────┐
   │                  Encoding pipeline                       │
   │                                                          │
   │  ┌──────┐    ┌─────────┐    ┌────────────────────────┐   │
   │  │ PAD  │───▶│ encoder │───▶│       6D latent        │   │
   │  │ (3D) │    │ expand  │    │ P · A · D ·            │   │
   │  └──────┘    └─────────┘    │ intensity · valence ·  │   │
   │                             │ activation             │   │
   │                             └─────────┬──────────────┘   │
   │                                       │                  │
   │  ┌──────────────────────────────┐     │                  │
   │  │ rvq — 4 stages × 256 codes   │◀────┘                  │
   │  │                              │                        │
   │  │  stage1 → residual → stage2  │                        │
   │  │   ...   → stage3 → stage4    │                        │
   │  └──────────────┬───────────────┘                        │
   │                 ▼                                        │
   │            ┌─────────┐                                   │
   │            │  Glyph  │  [42, 17, 89, 203]                │
   │            └─────────┘                                   │
   └──────────────────────────────────────────────────────────┘

Arousal-adaptive similarity weights

Low arousal (calm):  [0.30, 0.30, 0.25, 0.15]   balanced
High arousal (urgent): [0.50, 0.30, 0.15, 0.05]   coarse priority

Under urgency, the coarse first stage dominates similarity — exactly how humans skip detail under stress.

🧬 Theoretical Background

Residual Vector Quantization — Défossez et al. (2022)

Based on EnCodec:

1. Quantize input → get residual.
2. Quantize the residual → get a finer residual.
3. Repeat for N stages.
4. Final representation = list of codebook indices.

Each stage captures progressively finer detail. With 4 stages × 256 codes per stage, viva_glyph addresses ~4.3 billion distinct emotional states.

PAD model — Mehrabian (1996)

Emotions as points in 3D space, each axis in [-1, 1]:

• Pleasure — sadness ↔ joy.
• Arousal — calm ↔ excitement.
• Dominance — submission ↔ control.

6D latent expansion

PAD is expanded into a richer latent vector before quantization:

intensity     = √(P² + A² + D²) / √3
valence_sign  = sign(P) × |P|^0.5
activation    = A × D

Hebbian learning + Oja’s rule — Hebb (1949) / Oja (1982)

“Neurons that fire together wire together,” with auto-normalization:

Δw = η × y × (x − w × y)

• Oja’s rule — auto-normalizing weight updates (equilibrium w* = 1.0).
• Dead-neuron prevention — y = max(w, ε) keeps weights escaping zero.
• Decay — associations weaken without reinforcement.
• Winner-takes-all — strongest association wins recall.

LLM validation — 2025-01-24

The Oja-rule implementation was cross-validated against four frontier LLMs with structured Hebbian-context system prompts:

Unanimous: formula correct, equilibrium correct, dead-neuron guard works.

🎨 Design Principles

📚 Public API Highlights

Hebbian learning

// Learn: when in context 7, use this glyph.
let engine = viva_glyph.learn(engine, 7, glyph)
let engine = viva_glyph.learn(engine, 7, glyph)   // strengthen

// Recall the strongest association for context 7.
let recalled = viva_glyph.recall(engine, 7)

Glyph similarity

import viva_glyph/glyph

let a = glyph.new([1, 2, 3, 4])
let b = glyph.new([1, 2, 5, 6])

// Simple — matching tokens / total
glyph.similarity(a, b)             // => 0.5

// Weighted — coarse tokens matter more
glyph.weighted_similarity(a, b)    // => 0.7

// Prefix sharing — coarse structure
glyph.shares_prefix(a, b, 2)       // => True

🗺️ Roadmap

🤝 Contributing

git checkout -b feature/your-feature
gleam test                  # 71 tests
gleam format --check src test
gleam build

See CHANGELOG for release history.

📖 References

• Défossez et al. (2022) — High Fidelity Neural Audio Compression (arXiv:2210.13438)
• Mehrabian (1996) — Pleasure-arousal-dominance: A general framework
• Hebb (1949) — The Organization of Behavior
• Oja (1982) — Simplified neuron model as a principal component analyzer
• Buechel & Hahn (2023) — Emotion Embeddings (LREC)

🌌 VIVA Ecosystem

Star if silicon should speak silicon ⭐

Created by Gabriel Maia · MIT License