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.

Pruébalo: escribe un ψ que el códec acepte

El paper no fija cómo se escribe un estado ΛD en JSON; deja la proyección como ejercicio. Aquí va una, con las claves iguales a los símbolos de este artículo para que la fórmula se lea en el propio documento:

Clave	Símbolo	Qué lleva
`T`	T	Un tipo de la ontología: `Moneda`, `Medida`, `Instante`, `Cantidad` o `Proposicion`.
`V`	V	El valor, con la forma exacta que exige su tipo.
`E.c`	c	La certeza, entre 0 y 1.
`E.tau`	τ	`[inicio, fin]`, dos instantes ISO 8601 con zona.
`E.rho`	ρ	El origen causal: sistema, sensor o modelo.
`E.delta`	δ	`axiomatico`, `observado`, `inferido` o `mutado`.
`E.eta`, `E.premisas`	η, ψᵢ	Solo si es inferido o mutado: la fidelidad de la inferencia y los estados de los que sale.

El ejemplo de partida es una inferencia de un agente de cobros: "Acme puede pagar la factura", deducido de la factura y del saldo. Es JSON válido, tiene todas las claves, y aun así miente dos veces: dice estar más seguro de lo que sus premisas permiten, y dice valer hasta diciembre cuando el saldo del que se deduce solo vale un día. El ejercicio aplica el teorema de degradación y la herencia de ventanas temporales, de forma recursiva, a cada premisa.

Ejercicio

Escribe un estado ΛD que el códec acepte

Escribe la proyección JSON de un estado ψ. Las claves son los símbolos del artículo: T, V y E; dentro de E, c, tau (τ), rho (ρ) y delta (δ). Si el dato es inferido o mutado, añade en E sus premisas (una lista de ψ) y eta (η). El ejemplo de partida es JSON válido y está completo… y aun así miente dos veces.

Empezar desde…

Tu JSON807 / 4000

Fallan 2 de 7 comprobaciones.

Proyección JSON

Pasa: Es JSON bien formado
La sombra está bien dibujada. Ahora, el objeto.
Pasa: ψ = ⟨T, V, E⟩ completo
Tipo, valor y estado epistémico presentes.

Invariantes

Pasa: Inv. 1 · Rigidez ontológica: V ∈ dom(T)
V ∈ dom(Proposicion).
Pasa: Inv. 4 · Acotación epistémica: c, τ, ρ y δ definidos
c = 0.9 · τ = [2026-09-10T09:00:00Z, 2026-12-31T23:59:59Z] · ρ = "agente-cobros/v2" · δ = inferido.

Primera ley

Pasa: Premisas válidas y η declarada
2 premisas válidas, η = 0.9.
Falla: c ≤ min(cᵢ) × η
c = 0.9 > 0.8 × 0.9 = 0.72. La conclusión no puede estar más segura que su premisa más floja, y además la inferencia cobra peaje. Máximo permitido: 0.72.

Tiempo

Falla: τ no excede la ventana de sus premisas
τ = [2026-09-10T09:00:00Z, 2026-12-31T23:59:59Z] se sale de [2026-09-10T08:30:00Z, 2026-09-11T08:30:00Z], el tramo en que todas las premisas son ciertas. Una conclusión no puede valer más tiempo que aquello de lo que se deduce.
Pendiente: Certeza efectiva ahora (umbral 0.6)
Se calcula con la hora de tu navegador.

Cuando no falle ninguna comprobación podrás guardarlo como rama.

Dos cosas que conviene saber. La primera: solo se comprueba lo que un documento aislado puede demostrar. La interpretación única y la conservación semántica (invariantes 2 y 3) son propiedades del runtime entre documentos, no de uno solo, así que aquí no aparecen. La segunda: la comprobación de certeza efectiva usa la hora de tu navegador. Si llegas a este artículo cuando las fechas del ejemplo ya pasaron, verás que tu solución nace caducada. No es un fallo del ejercicio: es la entropía temporal de la sección anterior, pasándote a ti.

Cuando pase, guárdalo como rama del artículo. Las ramas de otros lectores están en el historial colectivo, y cada una se puede forkear para corregirla o extenderla.

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.

Dónde ya compila: AXON

Una advertencia antes, porque cambia cómo debes leer esta sección: AXON lo construyo yo.

ΛD no se quedó en el papel. Es el modelo de datos de AXON —AXON programming language en la documentación, axon-lang en la terminal—, un lenguaje de programación compilado cuyo destino es un modelo de lenguaje en lugar de un procesador. Dos piezas de este artículo tienen ahí forma de código:

El sello ψ. La primitiva lambda de AXON —que no es la abstracción del cálculo λ— declara la ontología, la certeza, la ventana temporal, la procedencia y la derivación de lo que produce un flujo. Es T y E escritos en el programa, no en un comentario. Está en el ejemplo del sello epistémico (en inglés).
La certeza como tipo. AXON coloca cada salida del modelo en una escala doubt < speculate < believe < know, y el compilador rechaza el programa que intenta presentar un valor de nivel bajo como un hecho allí donde alguien va a actuar sobre él: al generar un documento, al escribir en un CRM, al avisar a una persona. Es el umbral que detiene, llevado del runtime al compilador. Lo explica la página de tipos epistémicos.

Lo que AXON no resuelve es lo mismo que ΛD tampoco resuelve: de dónde sale la ontología y quién asigna la certeza inicial. El compilador garantiza que la duda no se pierda por el camino, no que la primera cifra sea honesta.

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.