# LE TRIPLET — spec v0 de l'Adressage Génératif

> Le format éternel commun à la **position**, au **DM** et à la **réplication**.
> Ce qu'on gèle ici, c'est la primitive `C2` du paper *L'Adressage Génératif* (§2.2, P0) et
> le protocole *XI0N-résidu* de *fractales-de-reel* (§7) : une seule donnée, trois usages.
>
> J0bot · Juillet 2026 · AGPL-3.0 · **spec — v0** · `adressage-generatif-triplet-v0`
> Convention : `[POSÉ]` = gelé/décidé · `[HYPOTHÈSE]` = attendu mais non prouvé dans le repo.

## 0. Ce que ce document gèle

Une donnée n'est pas un contenu qu'on garde, c'est une **adresse** dans un espace génératif : un
point qu'on retrouve. La spec v0 fige le format de cette adresse — le **triplet** — et les trois
opérations dessus (LIRE, ÉCRIRE, ALIGNEMENT). Le triplet ne change plus en grandissant : c'est le
« connecteur logiciel » de XERB0XI0N, l'équivalent du CFC matériel. Tout le reste (les générateurs,
la navigation, le réseau) se construit *au-dessus* et peut évoluer ; le triplet, non.

## 1. La donnée — le triplet `[POSÉ]`

```
triplet = ( hash_générateur , coordonnées , hash_résidu )
          └─ BLAKE3, 32 o ─┘ └─ opaque ──┘ └─ BLAKE3, 32 o ─┘
```

Trois champs, tous de taille bornée. **Le triplet est pure adresse** : il ne contient aucun octet de
contenu, seulement des références vérifiables.

- **hash_générateur** — BLAKE3 d'un **générateur** : un programme pur, déterministe, sandboxé
  (module WASM, `C0`). Il se résout dans le store adressé par contenu (`C1`, modèle Git/BLAKE3) en un
  module exécutable. Le générateur est un **bien commun** : répliqué gratuitement, amorti sur toutes
  les données qui le citent.
- **coordonnées** — localisent la donnée *dans* ce générateur : seed, `x/y/z/t`, index Hilbert 4D du
  Cubion, clé, temps. Minuscule, une par donnée. Le format interne des coordonnées est propre au
  domaine du générateur ; le triplet les traite comme opaques.
- **hash_résidu** — BLAKE3 du **résidu** : l'écart, au bit près, entre ce que le générateur prédit
  et ce que le réel a fait. Se résout dans le store en un bloc d'octets (éventuellement vide). Le
  résidu est la **seule part qui exige du stockage** — l'unité de réel, le Tsoin.

Cas dégénérés `[POSÉ]` (rétrocompatibilité éternelle) : générateur = identité ⇒ résidu = la donnée
entière (stockage classique) ; résidu = vide ⇒ pure structure (génération procédurale). Le réel est
entre les deux, facturé à hauteur de sa surprise.

## 2. Les trois opérations `[POSÉ]`

Soit `G = store[hash_générateur]`, `R = store[hash_résidu]`.

- **LIRE** — `donnée = G(coordonnées) ⊕ R`.
  `⊕` est l'opérateur de recombinaison bit-exact du domaine (le cas dégénéré est un XOR / une somme).
  On régénère la prédiction et on y applique l'écart. Déterministe, bit pour bit, sur toute machine,
  à toute époque. *Complet en adresses, paresseux en calcul* : déplier coûte du calcul (profondeur de
  Bennett, §3), c'est le prix assumé.
- **ÉCRIRE** — choisir un générateur `G`, calculer `R = donnée ⊖ G(coordonnées)`, **ne garder que
  `R`**. Écrire, c'est ne conserver que l'écart au prédictible. Asymétrie assumée : lire est rapide,
  bien écrire est lent (trouver un bon `G` est coûteux, §3) ⇒ encodage différé + ré-encodage
  rétroactif quand un meilleur générateur apparaît (le système comprime son propre passé).
- **ALIGNEMENT** — deux nœuds partagent un générateur **ssi `hash_générateur` est égal des deux
  côtés**. C'est une égalité de hash, **décidable au bit** — pas une synchronisation floue. Deux
  triplets qui citent le même générateur ne diffèrent que par `(coordonnées, hash_résidu)` : on
  **diffe des adresses au lieu de transporter des blobs**. C'est le levier de tout le reste.

## 3. Les garde-fous honnêtes `[POSÉ]`

Sans eux, la promesse ment. Aucun n'est contournable.

1. **Le mur de Kolmogorov.** Le résidu d'un vrai aléatoire est **incompressible** : il coûte son
   poids plein, toujours. « Tout dans un kilo-octet » est faux. Le système *catalogue* cette borne
   au lieu de la cacher ; la part de réel-pur ne devient jamais gratuite.
2. **Le meilleur générateur est non-calculable.** `K(x)` n'est pas calculable ; la recherche
   universelle de Levin trouve l'optimum mais en temps exponentiel. On ne publie **jamais l'optimum** —
   on publie des **majorants nommés** (un panel de compresseurs identifiés, BIONLIB en est un) et une
   grandeur honnête : **`certitude = 1 − L_min / L_baseline`**, qui monte à chaque raffinement sans
   jamais atteindre 1. « Envoyer en fractale de réel » est aussi bon que le meilleur générateur connu
   du domaine, ni plus.
3. **Coût de dépliage (Bennett).** Un générateur court peut demander un temps de calcul énorme.
   Le triplet troque de la bande passante/du stockage contre du calcul chez le lecteur — bon échange
   sur un lien lent et lointain, pas toujours en local.
4. **Générateurs appris ≠ bit-exacts → opt-in au bord, jamais dans le format éternel.** Les codecs
   neuronaux (COIN/COIN++) et les floats non reproductibles entre architectures sont un **slot
   opt-in**, activable *au bord* d'un domaine, jamais dans le triplet gelé. Le cœur reste bit-exact
   (IFS entier, WASM de référence, quantization entière). Un générateur qui ne redonne pas le même bit
   partout ne peut pas porter un `hash_générateur` du format éternel.
5. **GPG non-optionnel.** Le résidu est la seule part irréductible et sensible ; il est **toujours**
   chiffré GPG au repos et en transit. Les générateurs, communs et publics, ne le sont pas.
6. **Opt-in & droit au silence.** Rien n'est capturé ni régénéré sans consentement explicite. Une
   donnée peut ne jamais être écrite. **Ne pas nuire** gouverne le format autant que le code.

## 4. Les trois applications — une donnée, trois usages

- **Position.** Une trajectoire GPS brute répète des blobs lat/long quasi identiques. En triplet :
  générateur = modèle de mouvement (vitesse ~constante, chemin prédictible) ; coordonnées = index
  temps ; résidu = l'**écart** à la position prédite. On ne stocke que la surprise du déplacement.
  La coordonnée *est* la position ; le blob répété disparaît.
- **DM entre amis.** Deux amis qui partagent le même `hash_générateur` (leur contexte commun : langue,
  historique, modèle partagé) n'échangent que `(coordonnées, résidu)` — le résidu étant **l'écart au
  prédictible**. Le récepteur régénère le reste. C'est `K(x | générateur) ≪ K(x)` : le message
  s'effondre à sa seule surprise. L'ALIGNEMENT par hash rend « on partage bien le même générateur »
  décidable, pas espéré.
- **Réplication.** Entre deux boxions/nœuds, on ne **transmet et ne chiffre (GPG) que les résidus** ;
  les générateurs sont des **communs gratuits**, déjà des deux côtés (règle 50/50 : le réseau protège
  exactement l'irréductible). Mars↔Terre n'échangent que ce que l'autre ne pouvait pas prédire.

Le fil commun : dans les trois cas, ce qui voyage/se garde n'est jamais l'instant, c'est **l'écart
entre l'instant et ce que l'autre bout savait déjà en prédire.** Position, DM et réplication sont la
même opération à trois échelles.

## 5. Ce que ça débloque concrètement dans le repo

- **Manifeste de réplication diff-only.** Aujourd'hui `/replicate` pousse un **bundle complet signé**
  (les deux bouts ne partagent pas encore le générateur). Le triplet transforme ça en réplication
  **diff-only** : le manifeste devient une liste de triplets ; quand `hash_générateur` est déjà
  présent chez le récepteur (ALIGNEMENT), on ne transmet que `(coordonnées, hash_résidu)` + le résidu
  chiffré GPG. C'est *XI0N-résidu* (§7 de *fractales-de-reel*) — une page de protocole, pas une techno
  à inventer, testable dès aujourd'hui en logiciel sur le xion (deux nœuds fédérés, gain mesuré comme
  le 882× : octets du résidu vs octets de l'instant déplié).
- **Bion network.** Un bion *est* un tsoin : il ne stocke pas sa sortie, il stocke son générateur
  (référence/recette) et se rejoue. C'est le triplet descendu au niveau primitive
  (`timer-tsoin = {ms}`, `son-tsoin = {source, id, position}`). Le format v0 donne à un bion runtime
  (WASM, ex. `json_str`) et à un bion web (`timer-bion`) **le même identifiant** (`hash_générateur`),
  donc un ploxion-écran peut référencer un bion partagé au lieu de le recopier : la flotte passe de N
  monolithes à un alphabet de bions + une nuée de specs. Le triplet est le contrat qui rend un bion
  citable, partageable et rejouable à travers les deux mondes.
- **Contrat jOSPresence.** La présence live (curseurs, post-its LWW, collab) n'a pas besoin d'émettre
  l'état : un émetteur et un récepteur qui partagent le `hash_générateur` d'un modèle de présence
  n'échangent que `(coordonnées, résidu)` sur le PL0XI0N Bus, et le récepteur régénère. Le format v0
  fige le paquet que jOSPresence met sur le bus — l'écart, chiffré, aligné par hash — au lieu d'un
  blob d'état répété.

---

*Reste à faire (P1 du paper) : le codec aller-retour `image → triplet → image` bit-pour-bit, mesuré
vs PNG/JPEG, qui prouve `⊕` sur un vrai média. La navigation Hilbert (`C5`, zoom = descente Merkle)
consomme ce même format.*

*Décisions encore ouvertes (héritées de §12 du paper) : nom canonique du composant · sémantique de
**merge** des résidus (deux écarts concurrents sur le même point) · périmètre exact du gel v1.*

*Ne pas nuire. On ne transmet jamais du réel — seulement de la surprise sur fond de structure commune.*
*AGPL-3.0 · Juillet 2026 · adressage-generatif-triplet-v0*