Lambda Data (ΛD): datos que saben lo que son y cuánto se creen

El cambio de unidad

Si JSON es la sombra, la pregunta seria es qué forma tiene el objeto que la proyecta. ΛD (Lambda Data) da una respuesta concreta y comprobable: la unidad de información deja de ser un valor y pasa a ser un estado.

ψ = ⟨ T, V, E ⟩

T es el tipo ontológico: un nodo de un grafo de ontología verificado —Moneda, Instante, Medida, Cantidad—, no un primitivo de memoria como string o int32.
V es el valor válido: una magnitud o símbolo que satisface la topología interna de T. Fuera de dom(T) no es un valor equivocado: no es un valor.
E es el tensor epistémico: la condición de conocimiento del sistema respecto de V.

El axioma que sostiene todo lo demás es deliberadamente agresivo: un valor despojado de su estado epistémico y de su anclaje ontológico es entropía computacional. No es un dato pobre. Es ruido con buena presentación.

El tensor epistémico

Aquí es donde el dato deja de ser estático:

E = ⟨ c, τ, ρ, δ ⟩

Componente	Qué es	Qué te deja hacer
`c ∈ [0,1]`	Certeza. `1.0` solo para axiomas o medida directa.	Distinguir "lo sé" de "lo he deducido con un 0,6".
`τ = [t₀, t₁]`	Ventana temporal de validez.	Que un dato caduque solo, sin cron ni invalidación manual.
`ρ`	Procedencia: el origen causal (`Sensor_X`, `LLM_Y`).	Auditar de dónde salió cada número, cuatro saltos después.
`δ`	Derivación: axiomático, observado, inferido o mutado.	Tratar distinto lo medido y lo imaginado.

Compara los dos mundos con el mismo hecho:

{ "saldo": 100, "moneda": "USD", "cliente": "acme" }

ψ = ⟨ Moneda,
      100 USD,
      ⟨ c = 0.98,
        τ = [2026-09-09T10:00Z, 2026-09-09T23:59Z],
        ρ = core-banking/ledger#4471,
        δ = observado ⟩ ⟩

El JSON de arriba es una foto sin fecha ni autor. El de abajo dice quién lo vio, cuándo deja de valer y cuánto se lo cree.

Los cuatro invariantes

ΛD no los llama reglas de validación sino invariantes, en sentido físico: si uno se rompe, el estado no queda inválido, es que colapsa. No hay un ψ degradado circulando por el sistema.

Rigidez ontológica. Si V ∉ dom(T), colapso. El escalar 100 es inválido cuando T = Moneda: le falta la moneda, y sin ella no denota nada. Esto mata la ambigüedad estructural en el origen, no en el consumidor.
Interpretación semántica única. Un dato tiene una sola lectura válida, sea quien sea quien lo consuma. Esto liquida la falacia central de la integración de APIs: "depende de quién lo lea". El contexto va atado al dato, no al lector.
Conservación semántica. Ninguna transformación válida puede perder significado. El operador ≡sem sustituye a la igualdad sintáctica ==: ⟨Moneda, 100 USD, E⟩ y ⟨Moneda, 400.000 COP, E⟩ son estructuralmente distintos e idénticos en significado para un t ∈ τ. Dos payloads que no coinciden byte a byte pueden ser el mismo hecho.
Acotación epistémica. Todo dato debe tener un E explícito o deterministamente inferible. Certeza indefinida está prohibida. No hay null epistémico: si no sabes cuánto te lo crees, no lo publicas.

El cuarto es el que más código rompe, y por eso es el que importa. La mayoría de los sistemas que están hoy en producción no podrían emitir un solo dato bajo esa regla.

El teorema que sí es útil

Aquí está, para mí, la parte que justifica el paper entero. ΛD modela las operaciones como transformaciones termodinámicas, y de ahí sale una cota dura:

c(ψ_out) ≤ ( mínimo de c(ψ_i) ) × η_Φ

En castellano: una conclusión no puede ser más segura que la más floja de sus premisas, y además cada paso cobra peaje (η_Φ ∈ (0,1], la fidelidad epistémica de la transformación).

No es una heurística de producto: es la desigualdad de procesamiento de datos aplicada a la cognición. El procesamiento no crea información ex nihilo. Un agente no puede deducir verdad absoluta a partir de premisas probabilísticas, por muy bien redactada que le salga la frase.

Con números, una cadena de tres saltos partiendo de c = 0.8 con η = 0.9:

salto 1:  0.80  × 0.9 = 0.720
salto 2:  0.720 × 0.9 = 0.648
salto 3:  0.648 × 0.9 = 0.583   ← por debajo del umbral (0.6)

Y aquí está el comportamiento que lo convierte en ingeniería y no en filosofía: cuando c(ψ_out) cae por debajo del umbral cognitivo del sistema, el runtime no responde. Detiene la ejecución y enruta a una herramienta de verificación (inferencia activa).

Fíjate bien en lo que hace y en lo que no hace. No vuelve verídico al modelo. Lo que hace es convertir la ignorancia del sistema en un valor observable y accionable, en vez de en una frase segura de sí misma. La alucinación deja de propagarse no porque se detecte, sino porque la certeza necesaria para seguir ya no está disponible.

Compáralo con lo que hacemos hoy: un modelo con c = 0.6 interno emite texto que se lee como c = 1.0. Esa conversión silenciosa es la violación de la desigualdad, y está en todas partes —incluida la temperatura con la que muestreas, que ajusta cuánto se dispersa la salida pero no cuánto sabe el sistema.

La verdad caduca

τ merece un párrafo aparte porque es lo que menos se discute y más problemas causa. ΛD sostiene que el conocimiento sufre entropía temporal: fuera de su ventana, la certeza decae a cero. No a "quizá". A cero.

Piensa cuántos bugs de tu último año fueron exactamente esto: un dato que fue correcto, que siguió circulando, que nadie invalidó, y que en algún momento se volvió mentira sin cambiar ni un byte. Una caché sin TTL es un τ = [t₀, ∞) declarado por accidente.

JSON, degradado a códec

ΛD no pide que apagues JSON sobre TCP/IP. Lo relega a mecanismo de codificación: una proyección holográfica, la sombra de menor dimensionalidad de un estado cognitivo. Cuando un sistema ΛD ingiere JSON actúa como códec holográfico: evalúa la sintaxis contra los invariantes y eleva la carga otra vez a un estado multidimensional.

Conviene decir dónde está el trabajo sucio, porque el paper lo pasa de puntillas: elevar exige la ontología ya construida y una política que decida de dónde salen c, τ, ρ y δ cuando el payload no los trae —que es siempre, si el emisor es un sistema que ya existe. Ahí ΛD deja de ser matemáticas y se convierte en un proyecto de integración con presupuesto. Es la parte que el paper enuncia y no resuelve, y es la munición principal del contraargumento.

Qué puedes robar de aquí sin adoptar nada

No hace falta comprar el framework para llevarte lo que funciona:

Que la unidad viva en el tipo, no en el nombre de la clave. importeEUR es un comentario; un tipo Money que se niega a sumar monedas distintas es un invariante.
Propaga procedencia de verdad. No un campo source decorativo: uno que la frontera siguiente esté obligada a leer y a reenviar. Si se puede ignorar sin romper nada, no existe.
Compón la certeza con mínimo y producto. Es una línea de código, y evita el error más caro de las cadenas de agentes: que la confianza suba al avanzar.
Pon un umbral que detenga. Un sistema que a veces contesta "no con estos datos" vale más que uno que siempre contesta. Es la misma disciplina que hace útil a RAG cuando se le instruye para admitir que no encontró nada.

Las cuatro caben en un sprint y no necesitan grafo ontológico. Que quede claro: tampoco te dan ΛD. Te dan la parte del beneficio que no exige consenso global.

Para llevarte

ΛD cambia la unidad: de valor a estado ⟨T, V, E⟩.
Los invariantes no validan, colapsan: un dato sin certeza definida no circula.
El teorema de degradación pone una cota dura a la confianza de una cadena de inferencias.
El valor práctico no es "verdad garantizada", es ignorancia observable.
Lo difícil no son las matemáticas: es de dónde sacas la ontología y quién asigna c.