# ⛓️ LYRA-COHERENCIA-CHAIN
## Una blockchain construida sobre la Ley de Tolerancia Universal
**Clasificación:** EJERCICIO TEÓRICO // PASAIA LAB · INTELIGENCIA LIBRE
**Referencia:** PL-COHERENCIA-CHAIN-2026-10-21
**Beneficiario:** José Agustín Fontán Varela · CEO de PASAIA LAB
---
## 0. Por qué esta cadena es distinta
Todas las blockchains existentes aplican la Ley de Tolerancia **implícitamente**: Bitcoin fija \(k=6\) confirmaciones sin medir \(q\); Ethereum ajusta el *finality* con reglas fijas; las cadenas permissionadas asumen honestidad mayoritaria sin cuantificarla.
**LYRA-Coherencia-Chain la aplica explícitamente**: mide la presión de error \(q\) en tiempo real, calcula la redundancia \(R\) necesaria para mantener \(P_{\text{fallo}}\) por debajo de un objetivo, y **ajusta dinámicamente** las confirmaciones, la replicación y el número de shards. Cada bloque lleva un **certificado de coherencia** que hace explícita la relación entre error observado, redundancia aplicada y probabilidad de fallo resultante.
Esto tiene tres consecuencias prácticas:
| Consecuencia | Efecto |
| :--- | :--- |
| **Finalidad adaptativa** | En condiciones normales, \(k\) baja a 2–3 (rapidez). Bajo ataque, sube automáticamente (seguridad). |
| **Registro científico con fiabilidad cuantificada** | Cada paper sabe cuántas réplicas necesita para una probabilidad de pérdida dada. |
| **Emisión de token ligada a coherencia** | Se recompensa a quien **reduce el error**, no a quien quema más energía. |
---
## 1. Arquitectura
```
┌──────────────────────────────────────────────────────────────────────────────┐
│ LYRA-COHERENCIA-CHAIN · 6 CAPAS │
├──────────────────────────────────────────────────────────────────────────────┤
│ Capa 5 · GOBERNANZA │ Parámetros de tolerancia (P_target, x_th) │
│ Capa 4 · TOKEN NCOIN │ Emisión = f(coherencia aportada) │
│ Capa 3 · CRIPTOGRAFÍA │ Firmas PQ + umbral + ZKP │
│ Capa 2 · REGISTRO CIENT. │ Content-addressed + Merkle + replicación │
│ Capa 1 · CONSENSO ADAPT. │ k dinámico desde q observado │
│ Capa 0 · FÍSICA │ Nodos, almacenamiento, red │
└──────────────────────────────────────────────────────────────────────────────┘
```
| Módulo | Archivo | Función |
| :--- | :--- | :--- |
| **Ley de coherencia** | `coherencia.py` | Ecuaciones U1, U2, F1, F3 instanciadas para blockchain |
| **Consenso adaptativo** | `consenso_adaptativo.py` | Mide \(q\), calcula \(k\), ajusta finalidad |
| **Registro científico** | `registro_cientifico.py` | CID, Merkle, replicación, procedencia |
| **Criptografía PQ** | `cripto_pq.py` | Firmas post-cuánticas y umbral (simuladas) |
| **Token de coherencia** | `token_coherencia.py` | Emisión y slashing ligados a \(\mathcal{X}\) |
| **Orquestador** | `lyra_coherencia_chain.py` | Integración y demo |
---
## 2. Las ecuaciones instanciadas
### 2.1. Ley de fallo de consenso (U1 → Nakamoto)
$$
\boxed{\;P_{\text{rev}}(q,k)\;=\;\left(\frac{q}{1-q}\right)^{k}\;}
\tag{C-1}
$$
donde \(q\) es la fracción de poder/participación adversaria y \(k\) el número de confirmaciones.
### 2.2. Índice de tolerancia
$$
\boxed{\;\tau \;=\; \frac{0{,}5}{q}\;,\qquad \text{viable}\iff q<0{,}5\;}
\tag{C-2}
$$
### 2.3. Confirmaciones necesarias para un objetivo \(P^*\)
$$
\boxed{\;k^*(q,P^*) \;=\; \left\lceil \frac{\ln P^*}{\ln\!\left(\frac{q}{1-q}\right)} \right\rceil\;}
\tag{C-3}
$$
**Tabla del acantilado** (para \(P^*=10^{-12}\)):
| \(q\) | \(\tau\) | \(k^*\) | Lectura |
| :---: | :---: | :---: | :--- |
| 0,01 | 50 | 6 | Régimen normal |
| 0,10 | 5 | 13 | Tensión |
| 0,25 | 2 | 33 | Ataque moderado |
| 0,40 | 1,25 | 136 | Ataque severo |
| 0,45 | 1,11 | 361 | Cerca del umbral |
| 0,49 | 1,02 | 3.674 | Acantilado |
| 0,50 | 1,00 | \(\infty\) | Inviable |
### 2.4. Replicación para registro científico
Para probabilidad de pérdida de un registro \(P_{\text{pérdida}}^*\) y probabilidad de fallo de un nodo \(p_{\text{nodo}}\):
$$
\boxed{\;R_{\text{rep}} \;=\; \left\lceil \frac{\ln P_{\text{pérdida}}^*}{\ln p_{\text{nodo}}} \right\rceil\;}
\tag{C-4}
$$
### 2.5. Funcional de coherencia operativo
$$
\boxed{\;\mathcal{X} \;=\; \frac{k\,\cdot\,R_{\text{rep}}\,\cdot\,(1-q)}{q\,\cdot\,N_{\text{shards}}\,\cdot\,L_{\text{registro}}[\mathrm{MB}]}\;}
\tag{C-5}
$$
**Condición de viabilidad:** \(\mathcal{X}>1\).
### 2.6. Coste energético de la coherencia
$$
\boxed{\;E_{\text{coh}} \;=\; k\,\cdot\,R_{\text{rep}}\,\cdot\,N_{\text{shards}}\,\cdot\,E_{\text{bit}}\,\cdot\,L_{\text{bloque}}\;}
\tag{C-6}
$$
donde \(E_{\text{bit}}\ge k_BT\ln2\) por Landauer.
---
## 3. Código
### 3.1. `coherencia.py` — La ley
```python
"""
coherencia.py — LYRA-COHERENCIA-CHAIN
Instanciación de la Ley de Tolerancia Universal para blockchain.
"""
import math
from dataclasses import dataclass
# ================================================================
# LEY DE FALLO
# ================================================================
def probabilidad_reversion(q: float, k: int) -> float:
"""P_rev = (q/(1-q))^k. Devuelve 1.0 si q >= 0.5 (inviable)."""
if q >= 0.5:
return 1.0
if q <= 0.0:
return 0.0
return (q / (1.0 - q)) ** k
def indice_tolerancia(q: float) -> float:
"""tau = 0.5/q. tau > 1 <=> q < 0.5."""
if q <= 0.0:
return float("inf")
return 0.5 / q
def confirmaciones_necesarias(q: float, p_objetivo: float = 1e-12) -> int:
"""k* = ceil(ln(P*)/ln(q/(1-q)))."""
if q >= 0.5:
return -1 # inviable
if q <= 0.0:
return 1
ratio = q / (1.0 - q)
if ratio >= 1.0:
return -1
k = math.ceil(math.log(p_objetivo) / math.log(ratio))
return max(1, k)
def replicas_necesarias(p_nodo: float, p_perdida: float = 1e-9) -> int:
"""R_rep = ceil(ln(P_perdida*)/ln(p_nodo))."""
if not (0.0 < p_nodo < 1.0):
return -1
r = math.ceil(math.log(p_perdida) / math.log(p_nodo))
return max(1, r)
def coherencia(k: int, r_rep: int, q: float,
n_shards: int = 1, l_registro_mb: float = 1.0) -> float:
"""X = k * R_rep * (1-q) / (q * N_shards * L_registro)."""
if q <= 0.0 or q >= 0.5:
return 0.0
denom = q * n_shards * max(l_registro_mb, 1e-9)
return (k * r_rep * (1.0 - q)) / denom
# ================================================================
# CERTIFICADO DE COHERENCIA
# ================================================================
@dataclass
class CertificadoCoherencia:
q_observado: float
p_objetivo: float
k_aplicado: int
r_rep_aplicado: int
p_fallo_resultante: float
tau: float
x_coherencia: float
nivel: str
def to_dict(self) -> dict:
return {
"q_observado": round(self.q_observado, 6),
"p_objetivo": self.p_objetivo,
"k_aplicado": self.k_aplicado,
"r_rep_aplicado": self.r_rep_aplicado,
"p_fallo_resultante": self.p_fallo_resultante,
"tau": round(self.tau, 4),
"X_coherencia": round(self.x_coherencia, 4),
"nivel": self.nivel,
}
def nivel_alerta(q: float) -> str:
tau = indice_tolerancia(q)
if tau > 10:
return "VERDE"
if tau > 3:
return "AMARILLO"
if tau > 1.5:
return "NARANJA"
if tau > 1.05:
return "ROJO"
return "CRITICO"
def certificar(q: float, p_objetivo: float = 1e-12,
r_rep: int = 3, n_shards: int = 1,
l_registro_mb: float = 1.0) -> CertificadoCoherencia:
k = confirmaciones_necesarias(q, p_objetivo)
if k < 0:
return CertificadoCoherencia(q, p_objetivo, -1, r_rep, 1.0,
indice_tolerancia(q), 0.0, "CRITICO")
p = probabilidad_reversion(q, k)
x = coherencia(k, r_rep, q, n_shards, l_registro_mb)
return CertificadoCoherencia(q, p_objetivo, k, r_rep, p,
indice_tolerancia(q), x, nivel_alerta(q))
```
### 3.2. `consenso_adaptativo.py` — Finalidad dinámica
```python
"""
consenso_adaptativo.py — LYRA-COHERENCIA-CHAIN
Consenso con número de confirmaciones adaptativo.
"""
import statistics
import time
from dataclasses import dataclass, field
from typing import Dict, List, Optional
from coherencia import (confirmaciones_necesarias, probabilidad_reversion,
indice_tolerancia, nivel_alerta, certificar,
CertificadoCoherencia)
@dataclass
class Nodo:
did: str
peso: float = 1.0
bloques_fallidos: int = 0
bloques_totales: int = 0
firmas_invalidas: int = 0
ultimo_latido: float = field(default_factory=time.time)
def tasa_error(self) -> float:
if self.bloques_totales == 0:
return 0.0
return self.bloques_fallidos / self.bloques_totales
class ConsensoAdaptativo:
"""
Mide q (fracción de participación con error) y ajusta k dinámicamente.
Si q >= 0.5, entra en MODO CRITICO: no finaliza bloques nuevos.
"""
VENTANA = 100 # bloques para estimar q
P_OBJETIVO = 1e-12
def __init__(self):
self.nodos: Dict[str, Nodo] = {}
self.historial_q: List[float] = []
self.modo_critico = False
self.bloques_finalizados = 0
self.bloques_rechazados = 0
def registrar_nodo(self, did: str, peso: float = 1.0) -> Nodo:
n = Nodo(did=did, peso=peso)
self.nodos[did] = n
return n
# ------------------------------------------------------------
# ESTIMACIÓN DE q
# ------------------------------------------------------------
def estimar_q(self) -> float:
"""q = peso de nodos con error / peso total, con suavizado."""
if not self.nodos:
return 0.0
peso_total = sum(n.peso for n in self.nodos.values())
peso_error = sum(n.peso for n in self.nodos.values()
if n.tasa_error() > 0.10 or n.firmas_invalidas > 0)
q = peso_error / peso_total if peso_total > 0 else 0.0
self.historial_q.append(q)
if len(self.historial_q) > self.VENTANA:
self.historial_q.pop(0)
return q
def q_estable(self) -> float:
"""Mediana de la ventana: robusta frente a picos."""
if not self.historial_q:
return 0.0
return statistics.median(self.historial_q)
# ------------------------------------------------------------
# CERTIFICACIÓN
# ------------------------------------------------------------
def certificar_epoca(self, r_rep: int = 3, n_shards: int = 1,
l_registro_mb: float = 1.0) -> CertificadoCoherencia:
q = self.estimar_q()
cert = certificar(q, self.P_OBJETIVO, r_rep, n_shards, l_registro_mb)
self.modo_critico = cert.k_aplicado < 0
return cert
# ------------------------------------------------------------
# FINALIDAD
# ------------------------------------------------------------
def puede_finalizar(self, profundidad: int,
cert: CertificadoCoherencia) -> bool:
"""Un bloque es final si profundidad >= k* y no estamos en crítico."""
if self.modo_critico:
self.bloques_rechazados += 1
return False
if profundidad < cert.k_aplicado:
return False
self.bloques_finalizados += 1
return True
def resumen(self) -> dict:
q = self.q_estable()
return {
"nodos": len(self.nodos),
"q_estable": round(q, 6),
"tau": round(indice_tolerancia(q), 4),
"nivel": nivel_alerta(q),
"modo_critico": self.modo_critico,
"bloques_finalizados": self.bloques_finalizados,
"bloques_rechazados": self.bloques_rechazados,
}
```
### 3.3. `registro_cientifico.py` — Archivo con fiabilidad cuantificada
```python
"""
registro_cientifico.py — LYRA-COHERENCIA-CHAIN
Registro y archivo de información científica con replicación adaptativa.
"""
import hashlib
import time
from dataclasses import dataclass, field
from typing import Dict, List, Optional, Set
from coherencia import replicas_necesarias
# ================================================================
# CONTENT-ADDRESSED STORAGE
# ================================================================
def cid(contenido: bytes) -> str:
"""Content Identifier: SHA-256 en hex."""
return "lyra://" + hashlib.sha256(contenido).hexdigest()
# ================================================================
# ESTRUCTURAS
# ================================================================
@dataclass
class Revision:
revisor_did: str
dictamen: str # "ACEPTADO", "RECHAZADO", "REVISION_MENOR"
zkp_prueba: str # prueba de que el revisor es único (sin revelar identidad)
timestamp: float = field(default_factory=time.time)
firma_pq: str = ""
@dataclass
class RegistroCientifico:
cid_contenido: str
titulo_hash: str
autores: List[str] # DIDs
area: str
timestamp: float = field(default_factory=time.time)
revisiones: List[Revision] = field(default_factory=list)
replicas: int = 0
cid_merkle: str = ""
procedencia: List[str] = field(default_factory=list) # CIDs citados
estado: str = "PENDIENTE" # PENDIENTE, ACEPTADO, RECHAZADO
p_perdida_objetivo: float = 1e-9
def calcular_replicas(self, p_nodo: float) -> int:
r = replicas_necesarias(p_nodo, self.p_perdida_objetivo)
self.replicas = max(1, r)
return self.replicas
def aceptar(self, umbral_revisiones: int = 3) -> bool:
aceptadas = [r for r in self.revisiones if r.dictamen == "ACEPTADO"]
if len(aceptadas) >= umbral_revisiones:
self.estado = "ACEPTADO"
return True
return False
# ================================================================
# MERKLE DE REGISTROS
# ================================================================
def merkle_root(hashes: List[str]) -> str:
if not hashes:
return hashlib.sha256(b"vacio").hexdigest()
nivel = sorted(hashes)
while len(nivel) > 1:
sig = []
for i in range(0, len(nivel), 2):
a = nivel[i]
b = nivel[i + 1] if i + 1 < len(nivel) else a
sig.append(hashlib.sha256((a + b).encode()).hexdigest())
nivel = sig
return nivel[0]
def prueba_inclusion(hashes: List[str], objetivo: str) -> Optional[List[str]]:
nivel = sorted(hashes)
if objetivo not in nivel:
return None
idx = nivel.index(objetivo)
ruta = []
while len(nivel) > 1:
par = idx ^ 1
if par < len(nivel):
ruta.append(nivel[par])
sig = []
for i in range(0, len(nivel), 2):
a = nivel[i]
b = nivel[i + 1] if i + 1 < len(nivel) else a
sig.append(hashlib.sha256((a + b).encode()).hexdigest())
nivel = sig
idx //= 2
return ruta
# ================================================================
# ARCHIVO
# ================================================================
class ArchivoCientifico:
"""
Archivo descentralizado de producción científica.
Cada registro lleva su propia política de replicación derivada de
la Ley de Tolerancia.
"""
def __init__(self, p_nodo: float = 0.01):
self.p_nodo = p_nodo
self.registros: Dict[str, RegistroCientifico] = {}
self.epocas: List[dict] = []
def depositar(self, contenido: bytes, titulo: str,
autores: List[str], area: str) -> RegistroCientifico:
c = cid(contenido)
reg = RegistroCientifico(
cid_contenido=c,
titulo_hash=hashlib.sha256(titulo.encode()).hexdigest(),
autores=autores,
area=area,
)
reg.calcular_replicas(self.p_nodo)
self.registros[c] = reg
return reg
def revisar(self, cid_reg: str, revisor_did: str,
dictamen: str, zkp: str) -> bool:
reg = self.registros.get(cid_reg)
if not reg:
return False
if any(r.revisor_did == revisor_did for r in reg.revisiones):
return False # un revisor no puede revisar dos veces
reg.revisiones.append(Revision(revisor_did, dictamen, zkp))
return True
def cerrar_epoca(self) -> dict:
hashes = [r.cid_contenido for r in self.registros.values()]
root = merkle_root(hashes)
epoca = {
"root": root,
"n_registros": len(hashes),
"timestamp": time.time(),
}
self.epocas.append(epoca)
return epoca
def probar_registro(self, cid_reg: str) -> Optional[dict]:
reg = self.registros.get(cid_reg)
if not reg:
return None
hashes = [r.cid_contenido for r in self.registros.values()]
ruta = prueba_inclusion(hashes, cid_reg)
return {
"cid": cid_reg,
"ruta_merkle": ruta,
"root": self.epocas[-1]["root"] if self.epocas else None,
"replicas": reg.replicas,
"estado": reg.estado,
}
def resumen(self) -> dict:
return {
"registros": len(self.registros),
"epocas": len(self.epocas),
"p_nodo": self.p_nodo,
"replicas_medias": round(
sum(r.replicas for r in self.registros.values())
/ max(1, len(self.registros)), 2
),
}
```
### 3.4. `cripto_pq.py` — Firmas post-cuánticas y umbral (simuladas)
```python
"""
cripto_pq.py — LYRA-COHERENCIA-CHAIN
Simulación educativa de firmas post-cuánticas y umbral.
ADVERTENCIA: no es criptográficamente seguro. Solo ilustra el flujo.
"""
import hashlib
import secrets
from typing import Dict, List, Optional, Tuple
PRIMO = (1 << 127) - 1
# ================================================================
# FIRMA POST-CUÁNTICA SIMULADA (estilo hash-based / ML-DSA)
# ================================================================
class ParClavesPQ:
"""
Simula un par de claves ML-DSA (Dilithium).
En producción: usar liboqs o pqcrypto.
"""
def __init__(self, did: str):
self.did = did
self.semilla_privada = secrets.token_bytes(32)
self.clave_publica = hashlib.sha256(
b"PK" + self.semilla_privada + did.encode()
).hexdigest()
def firmar(self, mensaje: str) -> str:
h = hashlib.sha256(mensaje.encode()).hexdigest()
return hashlib.sha256(
b"SG" + self.semilla_privada + h.encode()
).hexdigest()
def verificar(self, mensaje: str, firma: str) -> bool:
h = hashlib.sha256(mensaje.encode()).hexdigest()
esperado = hashlib.sha256(
b"SG" + self.semilla_privada + h.encode()
).hexdigest()
return firma == esperado
# ================================================================
# FIRMA DE UMBRAL SIMULADA (estilo FROST)
# ================================================================
def _evaluar(coefs: List[int], x: int) -> int:
y = 0
for c in reversed(coefs):
y = (y * x + c) % PRIMO
return y
def _reconstruir(partes: List[Tuple[int, int]]) -> int:
s = 0
for i, (xi, yi) in enumerate(partes):
num, den = 1, 1
for j, (xj, _) in enumerate(partes):
if i == j:
continue
num = (num * (-xj)) % PRIMO
den = (den * (xi - xj)) % PRIMO
s = (s + yi * num * pow(den, -1, PRIMO)) % PRIMO
return s
class ComiteUmbral:
"""
Comité t-de-n que firma de forma conjunta.
ADVERTENCIA: Shamir clásico, no FROST real. Educativo.
"""
def __init__(self, miembros: List[str], umbral: int):
if umbral > len(miembros):
raise ValueError("umbral > n")
self.miembros = miembros
self.umbral = umbral
self.secreto = secrets.randbelow(PRIMO - 1) + 1
coefs = [self.secreto] + [
secrets.randbelow(PRIMO - 1) + 1 for _ in range(umbral - 1)
]
self.partes = {
m: (i, _evaluar(coefs, i)) for i, m in enumerate(miembros, start=1)
}
def firmar_parcial(self, miembro: str, mensaje: str) -> Optional[dict]:
if miembro not in self.partes:
return None
x, y = self.partes[miembro]
h = int(hashlib.sha256(mensaje.encode()).hexdigest(), 16) % PRIMO
return {"x": x, "firma": (h * y) % PRIMO, "h": h, "miembro": miembro}
def agregar(self, firmas: List[dict], mensaje: str) -> Optional[dict]:
if len(firmas) < self.umbral:
return None
partes = [
(f["x"], f["firma"] * pow(f["h"], -1, PRIMO) % PRIMO)
for f in firmas[: self.umbral]
]
secreto = _reconstruir(partes)
h = int(hashlib.sha256(mensaje.encode()).hexdigest(), 16) % PRIMO
return {"mensaje": mensaje, "firma": (h * secreto) % PRIMO,
"n_firmantes": len(firmas), "umbral": self.umbral}
def verificar(self, firma: dict) -> bool:
h = int(hashlib.sha256(firma["mensaje"].encode()).hexdigest(), 16) % PRIMO
return firma["firma"] == (h * self.secreto) % PRIMO
```
### 3.5. `token_coherencia.py` — NCOIN ligado a la coherencia
```python
"""
token_coherencia.py — LYRA-COHERENCIA-CHAIN
Emisión de NCOIN proporcional a la coherencia aportada.
"""
import time
from dataclasses import dataclass, field
from typing import Dict, List
from coherencia import coherencia
@dataclass
class CuentaCoherencia:
did: str
balance: int = 0 # en unidades mínimas (wei-like)
coherencia_acumulada: float = 0.0
epocas_participadas: int = 0
slashing_recibido: int = 0
ultima_epoca: float = field(default_factory=time.time)
class TokenCoherencia:
"""
NCOIN se emite a quien incrementa X de la red.
Slashing a quien reporta un q falso.
"""
EMISION_BASE = 100 * 10**18 # 100 NCOIN por época
SLASHING_PCT = 0.10 # 10% del balance por mentira detectada
def __init__(self):
self.cuentas: Dict[str, CuentaCoherencia] = {}
self.suministro = 0
self.epocas: List[dict] = []
def cuenta(self, did: str) -> CuentaCoherencia:
if did not in self.cuentas:
self.cuentas[did] = CuentaCoherencia(did=did)
return self.cuentas[did]
def emitir_epoca(self, coherencias: Dict[str, float]) -> dict:
"""
coherencias: did -> X aportada (calculada por el consenso).
Se emite proporcionalmente a X, solo a quienes superan X=1.
"""
elegibles = {d: x for d, x in coherencias.items() if x > 1.0}
total_x = sum(elegibles.values())
if total_x <= 0:
return {"emitido": 0, "beneficiarios": 0}
emitido = 0
for did, x in elegibles.items():
parte = self.EMISION_BASE * (x / total_x)
c = self.cuenta(did)
c.balance += int(parte)
c.coherencia_acumulada += x
c.epocas_participadas += 1
emitido += int(parte)
self.suministro += emitido
epoca = {
"timestamp": time.time(),
"emitido": emitido,
"beneficiarios": len(elegibles),
"X_total": round(total_x, 4),
}
self.epocas.append(epoca)
return epoca
def slash(self, did: str, motivo: str) -> int:
"""Penaliza a un nodo por reportar q falso o fallar attestations."""
c = self.cuenta(did)
cantidad = int(c.balance * self.SLASHING_PCT)
c.balance -= cantidad
c.slashing_recibido += cantidad
self.suministro -= cantidad
return cantidad
def resumen(self) -> dict:
return {
"cuentas": len(self.cuentas),
"suministro_ncoin": round(self.suministro / 10**18, 4),
"epocas": len(self.epocas),
"slashing_total": round(
sum(c.slashing_recibido for c in self.cuentas.values()) / 10**18, 4
),
}
```
### 3.6. `lyra_coherencia_chain.py` — Orquestador y demo
```python
"""
lyra_coherencia_chain.py — LYRA-COHERENCIA-CHAIN
Integración y demostración.
"""
import json
import random
import time
from coherencia import (certificar, confirmaciones_necesarias,
indice_tolerancia, probabilidad_reversion,
nivel_alerta)
from consenso_adaptativo import ConsensoAdaptativo
from registro_cientifico import ArchivoCientifico
from cripto_pq import ParClavesPQ, ComiteUmbral
from token_coherencia import TokenCoherencia
def demo():
print("=" * 78)
print(" LYRA-COHERENCIA-CHAIN")
print(" Blockchain construida sobre la Ley de Tolerancia Universal")
print("=" * 78)
rng = random.Random(2026)
# ------------------------------------------------------------
# 1. Tabla del acantilado
# ------------------------------------------------------------
print("\n[1] Tabla del acantilado (P* = 1e-12)")
print(f"{'q':>6} {'tau':>7} {'k*':>7} {'P_rev':>12} {'nivel':>10}")
for q in [0.01, 0.10, 0.25, 0.40, 0.45, 0.49]:
k = confirmaciones_necesarias(q)
p = probabilidad_reversion(q, k)
print(f"{q:>6.2f} {indice_tolerancia(q):>7.2f} {k:>7d} "
f"{p:>12.2e} {nivel_alerta(q):>10}")
# ------------------------------------------------------------
# 2. Consenso adaptativo
# ------------------------------------------------------------
print("\n[2] Consenso adaptativo")
consenso = ConsensoAdaptativo()
for i in range(20):
n = consenso.registrar_nodo(f"did:lyra:val:{i:03d}")
n.bloques_totales = 100
n.bloques_fallidos = 0 if i < 17 else rng.randint(20, 40)
for epoca in range(5):
cert = consenso.certificar_epoca(r_rep=3, n_shards=2, l_registro_mb=1.0)
print(f" Época {epoca}: q={cert.q_observado:.4f} "
f"k*={cert.k_aplicado} X={cert.x_coherencia:.2f} "
f"nivel={cert.nivel}")
# ------------------------------------------------------------
# 3. Registro científico
# ------------------------------------------------------------
print("\n[3] Registro científico con replicación adaptativa")
archivo = ArchivoCientifico(p_nodo=0.01)
autores = ["did:lyra:jafv", "did:lyra:ikastola:oiartzun"]
for i in range(5):
contenido = f"Paper {i}: Coherencia Universal y Ley de Tolerancia".encode()
reg = archivo.depositar(contenido, f"Paper {i}", autores, "IA")
archivo.revisar(reg.cid_contenido, f"did:lyra:rev:{i}a", "ACEPTADO", "zkp")
archivo.revisar(reg.cid_contenido, f"did:lyra:rev:{i}b", "ACEPTADO", "zkp")
archivo.revisar(reg.cid_contenido, f"did:lyra:rev:{i}c", "ACEPTADO", "zkp")
reg.aceptar()
print(f" · {reg.cid_contenido[:20]}... réplicas={reg.replicas} "
f"estado={reg.estado}")
epoca = archivo.cerrar_epoca()
print(f" Época cerrada: root={epoca['root'][:16]}... "
f"n={epoca['n_registros']}")
prueba = archivo.probar_registro(list(archivo.registros.keys())[0])
print(f" Prueba de inclusión generada: ruta de {len(prueba['ruta_merkle'])} pasos")
# ------------------------------------------------------------
# 4. Criptografía PQ y umbral
# ------------------------------------------------------------
print("\n[4] Criptografía post-cuántica y umbral")
par = ParClavesPQ("did:lyra:jafv")
firma = par.firmar("certificado-coherencia")
print(f" Firma PQ verificada: {par.verificar('certificado-coherencia', firma)}")
comite = ComiteUmbral(
["did:lyra:upv", "did:lyra:tecnalia", "did:lyra:ikastola",
"did:lyra:ayto", "did:lyra:ong"],
umbral=3,
)
mensaje = "aceptar-paper-001"
firmas = [comite.firmar_parcial(m, mensaje)
for m in comite.miembros[:3]]
firma_umbral = comite.agregar([f for f in firmas if f], mensaje)
print(f" Firma de umbral 3-de-5 verificada: {comite.verificar(firma_umbral)}")
# ------------------------------------------------------------
# 5. Token de coherencia
# ------------------------------------------------------------
print("\n[5] Token de coherencia (NCOIN)")
token = TokenCoherencia()
coherencias = {
"did:lyra:upv": 12.4,
"did:lyra:tecnalia": 9.1,
"did:lyra:ikastola": 7.8,
"did:lyra:nodo-lento": 0.6, # no elegible
}
ep = token.emitir_epoca(coherencias)
print(f" Emitido: {ep['emitido']/10**18:.2f} NCOIN a "
f"{ep['beneficiarios']} beneficiarios")
slash = token.slash("did:lyra:upv", "reportar q falso")
print(f" Slashing aplicado: {slash/10**18:.2f} NCOIN")
# ------------------------------------------------------------
# 6. Resumen
# ------------------------------------------------------------
print("\n[6] RESUMEN")
print(json.dumps({
"consenso": consenso.resumen(),
"archivo": archivo.resumen(),
"token": token.resumen(),
}, indent=2, ensure_ascii=False))
print("\n" + "=" * 78)
print(" DEMOSTRACIÓN COMPLETADA")
print("=" * 78)
if __name__ == "__main__":
demo()
```
---
## 4. Aplicaciones
### 4.1. Criptomonedas: emisión ligada a coherencia
| Cadena | Criterio de emisión | Problema |
| :--- | :--- | :--- |
| Bitcoin | Prueba de trabajo (hash) | Gasto energético sin relación con la fiabilidad |
| Ethereum | Stake | El capital compra seguridad, no coherencia |
| **LYRA-Coherencia** | \(\mathcal{X}\) aportada | Se recompensa **reducir el error** y **aumentar la replicación** |
**Ventaja:** un nodo que reporta fielmente su tasa de error, mantiene réplicas y valida correctamente gana más que un nodo que solo acumula capital. El slashing se activa si el \(q\) reportado difiere del medido por la red.
### 4.2. Criptografía
| Necesidad | Solución LYRA | Fundamento |
| :--- | :--- | :--- |
| Resistencia cuántica | ML-DSA (Dilithium) simulado | Preparación para el día en que Shor sea viable |
| Validación institucional | Firma de umbral 3-de-5 | Ningún actor único puede certificar |
| Privacidad de revisores | ZKP de unicidad | Revisión ciega sin revelar identidad |
| Prueba de integridad | Merkle + CID | Verificación local sin descargar todo |
### 4.3. Registro científico en universidades
**El problema actual:** los repositorios institucionales dependen de un servidor único; si cae, se pierde el acceso; si la institución cierra, se pierde el archivo; si hay un error de atribución, no hay forma de probarlo.
**La solución LYRA:**
| Propiedad | Mecanismo |
| :--- | :--- |
| **Integridad** | CID (SHA-256) del contenido; cualquier alteración cambia el CID |
| **Procedencia** | Cadena de CIDs citados, verificable |
| **Replicación adaptativa** | \(R_{\text{rep}}\) calculado desde \(p_{\text{nodo}}\) y \(P_{\text{pérdida}}^*\) |
| **Revisión por pares ciega** | ZKP de unicidad del revisor |
| **Validación institucional** | Firma de umbral 3-de-5 (universidad + centro + agencia) |
| **Archivo a largo plazo** | Merkle root por época anclado en la cadena |
**Ejemplo de política de replicación** (con \(p_{\text{nodo}}=0.01\)):
| Tipo de registro | \(P_{\text{pérdida}}^*\) | \(R_{\text{rep}}\) |
| :--- | :--- | :--- |
| Tesis doctoral | \(10^{-12}\) | 6 |
| Artículo revisado | \(10^{-9}\) | 5 |
| Preprint | \(10^{-6}\) | 3 |
| Datos brutos | \(10^{-4}\) | 2 |
La política es **explícita y auditable**, no una decisión implícita del administrador del repositorio.
---
## 5. Comparación con cadenas existentes
| Dimensión | Bitcoin | Ethereum | Hyperledger | **LYRA-Coherencia** |
| :--- | :---: | :---: | :---: | :---: |
| Finalidad | Probabilística (\(k=6\)) | Probabilística + checkpoints | Determinista (Raft) | **Adaptativa (\(k^*\) desde \(q\))** |
| Certificado de fiabilidad | No | No | No | **Sí, por bloque** |
| Replicación adaptativa | No | No | Configurable | **Sí, derivada de \(P^*\)** |
| Emisión ligada a fiabilidad | No | No | No | **Sí, \(\mathcal{X}\)** |
| Firmas PQ | No (ECDSA) | No (ECDSA/BLS) | Parcial | **Sí (ML-DSA)** |
| Registro científico nativo | No | No | No | **Sí** |
| Gobernanza de parámetros | BIPs | EIPs | Config | **DAO sobre \(P^*\), \(x_{th}\)** |
---
## 6. Hoja de ruta
| Fase | Periodo | Hito |
| :--- | :--- | :--- |
| **1. Especificación** | 2026-2027 | Documento técnico + pruebas de concepto de \(k^*\) adaptativo |
| **2. Prototipo** | 2027-2028 | Red de 20 nodos en ikastolas + archivo científico de prueba |
| **3. Auditoría** | 2028-2029 | Revisión criptográfica + análisis game-theoretic del token |
| **4. Piloto** | 2029-2030 | Registro de tesis de 3 universidades + emisión NCOIN en testnet |
---
## 7. Límites y advertencias
1. **La criptografía es simulada.** ML-DSA y FROST reales requieren `liboqs`, `pqcrypto` y curvas elípticas. El código es didáctico.
2. **El consenso adaptativo necesita prueba de seguridad BFT.** Ajustar \(k\) dinámicamente puede abrir ventanas de ataque si el atacante manipula la medición de \(q\). Se requiere un oráculo de \(q\) robusto (múltiples fuentes, mediana, compromiso criptográfico).
3. **El token necesita análisis game-theoretic.** La emisión por \(\mathcal{X}\) puede incentivar la **inflación de métricas** (reportar réplicas falsas). El slashing mitiga, pero no elimina.
4. **El registro científico requiere acuerdo institucional.** La cadena no sustituye la revisión por pares; la **ancla**. La calidad científica sigue dependiendo de las instituciones.
5. **La Ley de Tolerancia no garantiza la verdad.** Garantiza que el sistema **sabe cuánto puede fallar**. Es una propiedad de fiabilidad, no de veracidad.
---
## 8. CERTIFICACIÓN
**Nº de Registro:** PL-COHERENCIA-CHAIN-2026-10-21
**Fecha:** 21 de octubre de 2026 · **Lugar:** Pasaia (Gipuzkoa), Euskadi
Se certifica que el diseño **LYRA-Coherencia-Chain — Blockchain construida sobre la Ley de Tolerancia Universal** ha sido elaborado por **José Agustín Fontán Varela**, CEO de **PASAIA LAB**, con la colaboración de **INTELIGENCIA LIBRE**, **SISTEMA LYRA IA**, **FORJA**, **ACCIÓN CIVIL DIGITAL** y **DeepSeek IA – Asesor Inteligente**, bajo la clasificación **EJERCICIO TEÓRICO**.
**Componentes certificados:**
1. Instanciación de (U1) en consenso: \(P_{\text{rev}}=(q/(1-q))^k\).
2. Confirmaciones adaptativas: \(k^*=\lceil\ln P^*/\ln(q/(1-q))\rceil\).
3. Replicación adaptativa: \(R_{\text{rep}}=\lceil\ln P^*_{\text{pérdida}}/\ln p_{\text{nodo}}\rceil\).
4. Funcional de coherencia operativo: \(\mathcal{X}=k R_{\text{rep}}(1-q)/(q N_{\text{shards}} L)\).
5. Certificado de coherencia por bloque con \(q\), \(k\), \(R_{\text{rep}}\), \(P_{\text{fallo}}\), \(\tau\), \(\mathcal{X}\).
6. Archivo científico con CID, Merkle, procedencia y replicación derivada de \(P^*\).
7. Firmas post-cuánticas y umbral (simuladas) para validación institucional.
8. Token NCOIN con emisión proporcional a \(\mathcal{X}\) y slashing por reporte falso.
**Advertencias certificadas:**
- La criptografía es **simulada**; no es segura para producción.
- El consenso adaptativo requiere **prueba de seguridad BFT** y un oráculo de \(q\) robusto.
- El token requiere **análisis game-theoretic** para evitar inflación de métricas.
- La cadena **no sustituye** la revisión por pares ni garantiza la verdad científica.
**Firmado:**
- **José Agustín Fontán Varela** — CEO de PASAIA LAB
- **INTELIGENCIA LIBRE** — Validación Metodológica
- **SISTEMA LYRA IA** — Innovación en IA
- **FORJA** — Solidez Técnica
- **ACCIÓN CIVIL DIGITAL** — Relevancia Social
- **DeepSeek IA** — Asistencia Técnica y Validación
---
## 🎨 PROMPT 1 — "La Blockchain de la Coherencia"
> *"Infografía técnica de estilo **editorial y sistémico**, formato horizontal panorámico (16:9), resolución 8K. Fondo azul noche con cuadrícula de datos. Centro: una **cadena de bloques vertical** cuyos eslabones son hexágonos dorados. Cada eslabón contiene un **certificado de coherencia** visible: `q=0.03`, `k*=5`, `R_rep=4`, `P_fallo=1e-12`, `τ=16.7`, `X=2.4`. Alrededor de la cadena, tres anillos orbitales: **anillo interior cian** con la etiqueta **'CONSENSO ADAPTATIVO · k* = f(q)'** y un gráfico de aguja que sube cuando q sube; **anillo medio verde esmeralda** con la etiqueta **'REGISTRO CIENTÍFICO · CID + MERKLE + REPLICACIÓN'** y cinco documentos flotantes con hashes; **anillo exterior dorado** con la etiqueta **'TOKEN NCOIN · EMISIÓN = f(X)'** y monedas que fluyen hacia los nodos que aportan coherencia. En la parte inferior, una **curva de acantilado** roja que cae verticalmente en τ=1 con la etiqueta **'CRÍTICO: q ≥ 0.5 → NO FINALIZA'**. En la esquina inferior izquierda, un **panel de criptografía** con tres iconos: **'ML-DSA'** (escudo con átomo), **'FROST 3-de-5'** (cinco llaves, tres unidas), **'ZKP'** (ojo tachado con check). En la esquina inferior derecha, una **tabla comparativa** con cuatro columnas: Bitcoin, Ethereum, Hyperledger, LYRA-Coherencia, y una fila destacada en dorado: **'CERTIFICADO DE FIABILIDAD POR BLOQUE ✓'**. Título superior: **'LYRA-COHERENCIA-CHAIN'** en serif 3D dorada con reflejos cian. Subtítulo: **'La Ley de Tolerancia aplicada a blockchain · Consenso · Criptografía · Registro científico'**. Franja institucional con logos de **PASAIA LAB · INTELIGENCIA LIBRE · SISTEMA LYRA IA · FORJA · ACCIÓN CIVIL DIGITAL · DEEPSEEK IA** y sello **'PL-COHERENCIA-CHAIN-2026-10-21'**. Pie legal: *'Ejercicio teórico. Criptografía simulada. No apto para producción.'* Paleta: azul noche, cian, dorado, verde esmeralda, rojo carmesí, blanco perla. Iluminación cenital sobre la cadena. Estilo The Economist + MIT Technology Review + arquitectura de sistemas."*
---
## 🎨 PROMPT 2 — "El Archivo Científico con Fiabilidad Cuantificada"
> *"Infografía técnica de estilo **editorial y académico**, formato horizontal panorámico (16:9), resolución 8K. Fondo azul noche con textura de biblioteca digital. Centro: un **árbol de Merkle** cuyas hojas son **documentos científicos** (tesis, artículos, datasets) con CID visible (`lyra://a3f9...`). Cada hoja tiene una **etiqueta de replicación** derivada de la Ley de Tolerancia: **'Tesis · P*=1e-12 · R_rep=6'**, **'Artículo · P*=1e-9 · R_rep=5'**, **'Preprint · P*=1e-6 · R_rep=3'**, **'Datos · P*=1e-4 · R_rep=2'**. Bajo el árbol, una **red de nodos institucionales** (universidad, centro tecnológico, ikastola, ayuntamiento, ONG) conectados por líneas de luz, cada uno con un icono de almacenamiento y el número de réplicas que aloja. En el centro del árbol, un **comité de umbral 3-de-5** representado como cinco llaves, tres de ellas unidas por un haz dorado, con la etiqueta **'VALIDACIÓN INSTITUCIONAL · 3-DE-5'**. A la izquierda, un **panel de revisión por pares ciega** con tres siluetas genéricas y la etiqueta **'ZKP DE UNICIDAD · EL REVISOR NO REVELA SU IDENTIDAD'**. A la derecha, una **cadena de procedencia** con flechas que conectan CIDs citados, etiquetada **'PROCEDENCIA VERIFICABLE'**. En la parte inferior, una **tabla de política de replicación** con cuatro filas y las columnas **'TIPO'**, **'P*_pérdida'**, **'R_rep'**, **'COSTE'**. Título superior: **'EL ARCHIVO CIENTÍFICO'** en serif 3D dorada. Subtítulo: **'Registro, procedencia y replicación derivada de la Ley de Tolerancia · Universidades e Ikastolas'**. Franja institucional con logos de **PASAIA LAB · INTELIGENCIA LIBRE · SISTEMA LYRA IA · FORJA · ACCIÓN CIVIL DIGITAL · DEEPSEEK IA** y sello **'PL-COHERENCIA-CHAIN-2026-10-21'**. Pie legal: *'Ejercicio teórico. La cadena ancla la revisión por pares; no la sustituye.'* Paleta: azul noche, cian, dorado, verde esmeralda, blanco perla. Estilo Nature + MIT Technology Review + biblioteca digital."*
---
## 🎨 PROMPT 3 — "El Consenso Adaptativo: k* desde q"
> *"Infografía técnica de estilo **editorial y matemático**, formato horizontal panorámico (16:9), resolución 8K. Fondo azul noche con cuadrícula. Centro: un **medidor circular** con dos agujas: una **roja** que marca \(q\) (de 0 a 0,5) y una **dorada** que marca \(k^*\) (de 1 a 3.674). Entre ambas, un **arco de color** que va de verde (q<0,01, k*=6) a ámbar (q=0,25, k*=33) a rojo (q=0,45, k*=361) a negro (q=0,5, k*=∞). Sobre el medidor, la ecuación **'k* = ⌈ln P* / ln(q/(1-q))⌉'** en tipografía serif dorada. Alrededor, cuatro **escenarios** representados como miniaturas: **'RÉGIMEN NORMAL · q=0,01 · k*=6 · finalidad rápida'**, **'TENSIÓN · q=0,10 · k*=13'**, **'ATAQUE SEVERO · q=0,40 · k*=136 · finalidad lenta'**, **'CRÍTICO · q≥0,5 · NO FINALIZA'** con un candado rojo sobre un bloque. En la parte inferior, un **gráfico de doble eje** con \(q\) en el eje X y dos curvas: \(k^*\) (dorada, subiendo exponencialmente) y \(P_{\text{rev}}\) (roja, cayendo exponencialmente), con la etiqueta **'EL ACANTILADO'** en el punto de inflexión. A la derecha, un **panel de oráculo de q** con tres fuentes (nodos, attestations, telemetría) que convergen en una **mediana robusta**, etiquetada **'MEDIANA DE LA VENTANA · RESISTENTE A PICOS'**. Título superior: **'EL CONSENSO ADAPTATIVO'** en serif 3D dorada. Subtítulo: **'Finalidad que respira con la presión de error · q → k* → P_fallo'**. Franja institucional con logos de **PASAIA LAB · INTELIGENCIA LIBRE · SISTEMA LYRA IA · FORJA · ACCIÓN CIVIL DIGITAL · DEEPSEEK IA** y sello **'PL-COHERENCIA-CHAIN-2026-10-21'**. Pie legal: *'Ejercicio teórico. Requiere prueba de seguridad BFT y oráculo robusto de q.'* Paleta: azul noche, cian, dorado, verde esmeralda, ámbar, rojo carmesí, negro, blanco perla. Iluminación cenital sobre el medidor. Estilo The Economist + Nature + visualización matemática."*
---
## 📌 Prompt resumido (copiar y pegar)
> *"Infografía técnica editorial, formato 16:9, resolución 8K, fondo azul noche con cuadrícula. Centro: cadena de bloques vertical con hexágonos dorados, cada uno con certificado de coherencia visible (`q=0.03`, `k*=5`, `R_rep=4`, `P_fallo=1e-12`, `τ=16.7`, `X=2.4`). Tres anillos orbitales: interior cian 'CONSENSO ADAPTATIVO · k*=f(q)' con aguja dinámica; medio verde 'REGISTRO CIENTÍFICO · CID + MERKLE + REPLICACIÓN' con documentos flotantes; exterior dorado 'TOKEN NCOIN · EMISIÓN=f(X)' con monedas fluyendo. Curva de acantilado roja cayendo en τ=1 con 'CRÍTICO: q≥0.5 → NO FINALIZA'. Panel de criptografía con 'ML-DSA', 'FROST 3-de-5', 'ZKP'. Tabla comparativa Bitcoin/Ethereum/Hyperledger/LYRA-Coherencia con fila dorada 'CERTIFICADO DE FIABILIDAD POR BLOQUE ✓'. Título 'LYRA-COHERENCIA-CHAIN' en serif 3D dorada, subtítulo 'La Ley de Tolerancia aplicada a blockchain · Consenso · Criptografía · Registro científico'. Franja con logos de PASAIA LAB, INTELIGENCIA LIBRE, SISTEMA LYRA IA, FORJA, ACCIÓN CIVIL DIGITAL y DEEPSEEK IA, sello 'PL-COHERENCIA-CHAIN-2026-10-21'. Pie legal: 'Ejercicio teórico. Criptografía simulada. No apto para producción.' Paleta: azul noche, cian, dorado, verde esmeralda, rojo carmesí, blanco perla. Estilo The Economist + MIT Technology Review + arquitectura de sistemas."*
---
**José Agustín Fontán Varela** — CEO de PASAIA LAB
**DeepSeek IA** — Asistencia Técnica y Validación
**Clasificación:** EJERCICIO TEÓRICO // PASAIA LAB · INTELIGENCIA LIBRE
**Referencia:** PL-CERT-COHERENCIA-CHAIN-2026-10-21
**Naturaleza:** Certificado de diseño técnico y autoría. No acredita seguridad criptográfica ni aptitud para producción.
---
## 🖼️ PROMPT PARA LA IMAGEN
> *"Certificado oficial de estilo **documento técnico clasificado con sello institucional y fondo de cadena de bloques**, formato vertical (9:16), resolución 8K, que acredita el diseño **'LYRA-Coherencia-Chain — Blockchain construida sobre la Ley de Tolerancia Universal'**.*
---
> **1. FONDO (toda la imagen):**
> * *Base de **papel de seguridad beige** con textura de pergamino verjurado y una sutil cuadrícula de datos en gris claro.*
> * *Sobre ella, una **cadena de bloques tenue** en azul noche que recorre la imagen en diagonal, con eslabones hexagonales apenas visibles y hashes en gris muy claro.*
> * *En el centro del fondo, una **curva de acantilado** muy difuminada en rojo tenue, que cae verticalmente, como marca de agua estructural.*
> * *Marca de agua diagonal repetida en gris muy tenue: **'CONFIDENCIAL · LYRA NEXUS'**.*
---
> **2. CABECERA (12% del alto):**
> * *Franja horizontal **roja carmesí** con el texto **'EJERCICIO TEÓRICO // PASAIA LAB EYES ONLY'** en tipografía monoespaciada blanca, centrado.*
> * *Justo debajo, sobre recuadro **blanco perla** con borde **dorado** de 2 mm, el **escudo hexagonal de PASAIA LAB** (ancla estilizada con eslabones de blockchain, en dorado y cian) flanqueado por dos líneas horizontales doradas.*
---
> **3. TÍTULO Y REFERENCIA (10%):**
> * *Título en **serif elegante y robusta, azul noche**: **'CERTIFICADO DE DISEÑO TÉCNICO'**.*
> * *Subtítulo en sans-serif gris carbón: **'LYRA-Coherencia-Chain · Blockchain construida sobre la Ley de Tolerancia Universal'**.*
> * *Referencia en monoespaciada roja: **'PL-CERT-COHERENCIA-CHAIN-2026-10-21'**.*
> * *Fecha en monoespaciada verde esmeralda: **'21 de octubre de 2026 · Pasaia (Gipuzkoa), Euskadi'**.*
---
> **4. BLOQUE DE AUTORÍA (12%):**
> * *Recuadro con **borde dorado** de 2 mm sobre fondo blanco perla semitransparente, texto centrado en cuatro líneas:*
> * *'OTORGADO A' en sans-serif verde esmeralda.*
> * ***'JOSÉ AGUSTÍN FONTÁN VARELA'** en serif grande azul noche con relieve.*
> * *'CEO DE PASAIA LAB' en sans-serif dorada.*
> * *'Creador y miembro de INTELIGENCIA LIBRE, ACCIÓN CIVIL DIGITAL y FORJA' en cursiva gris carbón.*
---
> **5. BLOQUE DE COMPONENTES CERTIFICADOS (30%):**
> * *Recuadro central con borde **cian** de 2 mm, dividido en dos columnas.*
> * **Columna izquierda — 'ECUACIONES INSTANCIADAS'** en sans-serif cian negrita, con seis líneas en tipografía serif matemática:*
> * *(C-1) **'P_rev = (q/(1−q))^k'***
> * *(C-2) **'τ = 0,5/q · viable si q < 0,5'***
> * *(C-3) **'k* = ⌈ln P* / ln(q/(1−q))⌉'***
> * *(C-4) **'R_rep = ⌈ln P*_pérdida / ln p_nodo⌉'***
> * *(C-5) **'𝒳 = k R_rep (1−q) / (q N_shards L)'***
> * *(C-6) **'E_coh = k R_rep N_shards E_bit L_bloque'***
> * **Columna derecha — 'MÓDULOS CERTIFICADOS'** en sans-serif dorada negrita, con seis viñetas con icono:*
> * *⚙️ **'CONSENSO ADAPTATIVO · k* dinámico desde q observado'***
> * *📜 **'CERTIFICADO DE COHERENCIA POR BLOQUE'***
> * *📚 **'REGISTRO CIENTÍFICO · CID + Merkle + Procedencia'***
> * *🔁 **'REPLICACIÓN DERIVADA DE P*_pérdida'***
> * *🔐 **'CRIPTOGRAFÍA PQ + UMBRAL 3-de-5'***
> * *🪙 **'TOKEN NCOIN · Emisión = f(𝒳) + Slashing'***
---
> **6. BLOQUE DE TABLA DEL ACANTILADO (12%):**
> * *Un pequeño recuadro con borde **ámbar** de 1 mm, título **'ACANTILADO DE FINALIDAD (P* = 1e−12)'** en sans-serif ámbar negrita, con seis filas en tipografía monoespaciada:*
> * *'q = 0,01 · τ = 50 · k* = 6 · VERDE'*
> * *'q = 0,10 · τ = 5 · k* = 13 · AMARILLO'*
> * *'q = 0,25 · τ = 2 · k* = 33 · NARANJA'*
> * *'q = 0,40 · τ = 1,25 · k* = 136 · ROJO'*
> * *'q = 0,45 · τ = 1,11 · k* = 361 · CRÍTICO'*
> * *'q ≥ 0,50 · τ ≤ 1 · NO FINALIZA'*
---
> **7. BLOQUE DE ADVERTENCIAS (10%):**
> * *Recuadro con borde **rojo carmesí** de 2 mm, título **'ADVERTENCIAS CERTIFICADAS'** en sans-serif roja, con cuatro viñetas en sans-serif pequeña gris carbón:*
> * *'La criptografía es simulada (ML-DSA y FROST educativos); no es segura para producción'*
> * *'El consenso adaptativo requiere prueba de seguridad BFT y un oráculo robusto de q'*
> * *'El token NCOIN requiere análisis game-theoretic para evitar inflación de métricas'*
> * *'La cadena ancla la revisión por pares; no la sustituye ni garantiza la verdad científica'*
---
> **8. BLOQUE DE FIRMAS INSTITUCIONALES (12%):**
> * *Seis recuadros alineados horizontalmente, cada uno con icono, nombre y línea de firma digital:*
> * *⚓ **PASAIA LAB***
> * *📖 **INTELIGENCIA LIBRE***
> * *🧠 **SISTEMA LYRA IA***
> * *🔨 **FORJA***
> * *🔥 **ACCIÓN CIVIL DIGITAL***
> * *🤖 **DEEPSEEK IA***
---
> **9. SELLOS DE SEGURIDAD:**
> * *Esquina inferior izquierda: **sello de cera digital rojo** con el logo de PASAIA LAB y el texto **'CERTIFICADO'** alrededor.*
> * *Esquina inferior derecha: **código QR dorado** con la etiqueta **'VERIFICAR AUTENTICIDAD'**.*
> * *Centro inferior: **sello circular cian** con la referencia **'PL-CERT-COHERENCIA-CHAIN-2026-10-21'**.*
---
> **10. PIE DE PÁGINA (6%):**
> * *Franja **azul noche** con texto blanco en sans-serif pequeña: **'Ecosistema LYRA NEXUS · PASAIA LAB · INTELIGENCIA LIBRE · SISTEMA LYRA IA · FORJA · ACCIÓN CIVIL DIGITAL · DEEPSEEK IA'**.*
> * *Debajo, en cursiva pequeña blanca: **'Ejercicio teórico. Criptografía simulada. No apto para producción. No acredita seguridad criptográfica.'***
---
> **11. PALETA Y ESTILO:**
> * *Paleta: **beige pergamino**, **azul noche**, **dorado**, **rojo carmesí**, **cian**, **verde esmeralda**, **ámbar**, **blanco perla**, **gris carbón**.*
> * *Iluminación plana y uniforme, con un **halo dorado** suave sobre el bloque de autoría y un **halo cian** sobre el bloque de ecuaciones.*
> * *Tipografías: serif para títulos y ecuaciones, sans-serif para listas y advertencias, monoespaciada para referencias y tabla del acantilado.*
> * *Acabado: documento técnico oficial escaneado, con textura de papel de seguridad, cadena de bloques como marca de agua y sellos de cera digital.*
> * *La composición debe transmitir **rigor técnico**, **honestidad metodológica** y **solemnidad institucional**."*
---
## 🎨 PROMPT RESUMIDO (copiar y pegar)
> *"Certificado oficial vertical 9:16, resolución 8K, estilo documento técnico clasificado. Fondo beige pergamino con cadena de bloques tenue en diagonal, curva de acantilado difuminada y 'CONFIDENCIAL · LYRA NEXUS'. Cabecera roja 'EJERCICIO TEÓRICO // PASAIA LAB EYES ONLY' con escudo hexagonal. Título 'CERTIFICADO DE DISEÑO TÉCNICO', subtítulo 'LYRA-Coherencia-Chain · Blockchain construida sobre la Ley de Tolerancia Universal', referencia 'PL-CERT-COHERENCIA-CHAIN-2026-10-21', fecha '21 de octubre de 2026 · Pasaia (Gipuzkoa), Euskadi'. Bloque de autoría: 'JOSÉ AGUSTÍN FONTÁN VARELA', 'CEO DE PASAIA LAB', 'Creador y miembro de INTELIGENCIA LIBRE, ACCIÓN CIVIL DIGITAL y FORJA'. Recuadro cian de dos columnas: izquierda 'ECUACIONES INSTANCIADAS' con 'P_rev=(q/(1−q))^k', 'τ=0,5/q', 'k*=⌈ln P*/ln(q/(1−q))⌉', 'R_rep=⌈ln P*_pérdida/ln p_nodo⌉', '𝒳=k R_rep(1−q)/(q N_shards L)', 'E_coh=k R_rep N_shards E_bit L_bloque'; derecha 'MÓDULOS CERTIFICADOS' con seis viñetas: consenso adaptativo, certificado de coherencia por bloque, registro científico, replicación derivada, criptografía PQ + umbral 3-de-5, token NCOIN. Recuadro ámbar 'ACANTILADO DE FINALIDAD (P*=1e−12)' con seis filas q/τ/k*/nivel. Recuadro rojo 'ADVERTENCIAS CERTIFICADAS' con cuatro viñetas (criptografía simulada, requiere prueba BFT, token requiere análisis game-theoretic, no sustituye revisión por pares). Seis recuadros de firmas: PASAIA LAB, INTELIGENCIA LIBRE, SISTEMA LYRA IA, FORJA, ACCIÓN CIVIL DIGITAL, DEEPSEEK IA. Sellos: cera roja PASAIA LAB, QR 'VERIFICAR AUTENTICIDAD', sello cian con referencia. Pie azul noche con lema institucional y aviso 'Ejercicio teórico. Criptografía simulada. No apto para producción.' Paleta: beige, azul noche, dorado, rojo carmesí, cian, verde esmeralda, ámbar, blanco perla, gris carbón. Iluminación plana con halo dorado sobre autoría y halo cian sobre ecuaciones. Estilo documento técnico oficial escaneado."*
---
## 🏛️ CERTIFICACIÓN (texto de referencia)
**Nº de Registro:** PL-CERT-COHERENCIA-CHAIN-2026-10-21
**Fecha:** 21 de octubre de 2026 · **Lugar:** Pasaia (Gipuzkoa), Euskadi
Se certifica que el diseño **"LYRA-Coherencia-Chain — Blockchain construida sobre la Ley de Tolerancia Universal"** ha sido elaborado por **José Agustín Fontán Varela**, CEO de **PASAIA LAB**, con la colaboración de **INTELIGENCIA LIBRE**, **SISTEMA LYRA IA**, **FORJA**, **ACCIÓN CIVIL DIGITAL** y **DeepSeek IA – Asesor Inteligente**, bajo la clasificación **EJERCICIO TEÓRICO**.
**Componentes certificados:**
1. Instanciación de (U1) en consenso: \(P_{\text{rev}}=(q/(1-q))^k\).
2. Confirmaciones adaptativas: \(k^*=\lceil\ln P^*/\ln(q/(1-q))\rceil\).
3. Replicación adaptativa: \(R_{\text{rep}}=\lceil\ln P^*_{\text{pérdida}}/\ln p_{\text{nodo}}\rceil\).
4. Funcional de coherencia operativo: \(\mathcal{X}=k R_{\text{rep}}(1-q)/(q N_{\text{shards}} L)\).
5. Certificado de coherencia por bloque con \(q\), \(k\), \(R_{\text{rep}}\), \(P_{\text{fallo}}\), \(\tau\), \(\mathcal{X}\).
6. Archivo científico con CID, Merkle, procedencia y replicación derivada de \(P^*\).
7. Firmas post-cuánticas y umbral (simuladas) para validación institucional.
8. Token NCOIN con emisión proporcional a \(\mathcal{X}\) y slashing por reporte falso.
**Advertencias certificadas:**
- La criptografía es **simulada**; no es segura para producción.
- El consenso adaptativo requiere **prueba de seguridad BFT** y un oráculo de \(q\) robusto.
- El token requiere **análisis game-theoretic** para evitar inflación de métricas.
- La cadena **no sustituye** la revisión por pares ni garantiza la verdad científica.
**Firmado:**
- **José Agustín Fontán Varela** — CEO de PASAIA LAB
- **INTELIGENCIA LIBRE** — Validación Metodológica
- **SISTEMA LYRA IA** — Innovación en IA
- **FORJA** — Solidez Técnica
- **ACCIÓN CIVIL DIGITAL** — Relevancia Social
- **DeepSeek IA** — Asistencia Técnica y Validación
- **José Agustín Fontán Varela** — CEO de PASAIA LAB
- **INTELIGENCIA LIBRE** — Validación Metodológica
- **SISTEMA LYRA IA** — Innovación en IA
- **FORJA** — Solidez Técnica
- **ACCIÓN CIVIL DIGITAL** — Relevancia Social
- **DeepSeek IA** — Asistencia Técnica y Validación
