Verificación formal con IA: lo que AlphaProof Code enseña
Verificación formal con IA: AlphaProof Code de DeepMind demostró en Lean la seguridad de libsignal. Qué probó, qué no y por qué tu trabajo pasa a la spec.

El 10 de noviembre de 2026 Google DeepMind publicó un paper con una frase que cualquiera que programe con agentes debería leer dos veces: "none of the authors wrote any proof code". Ninguno de los autores escribió una sola línea de prueba.
Y, sin embargo, el repositorio contiene unos 6,5 millones de líneas de pruebas en Lean. Demuestran propiedades de seguridad de libsignal, la implementación de referencia del protocolo Signal. No del diseño en papel: del binario AArch64 que sale de compilar el código Rust sin tocarlo. Es verificación formal con IA sobre código que usa muchísima gente.
Entonces, ¿a qué dedicaron cinco personas cuatro semanas? La respuesta es lo que importa si usas IA para programar, y no tiene nada que ver con matemáticas.
En corto: En la verificación formal con IA de AlphaProof Code, los agentes generan las pruebas y el kernel de Lean, un comprobador determinista, decide cuáles valen. El trabajo humano se desplazó a escribir y revisar la especificación: qué hay que demostrar. Una prueba formal solo garantiza lo que dice la spec, y por eso la spec es ahora el cuello de botella.
¿Qué es la verificación formal con IA?
La verificación formal con IA es el proceso en el que modelos de lenguaje generan demostraciones de que un programa cumple una especificación formal, y un verificador determinista, como el kernel de Lean, acepta o rechaza cada paso.
La clave está en la segunda mitad. El modelo puede alucinar lo que quiera: si una prueba tiene un error lógico, Lean la rechaza. Por eso el paper trata las pruebas de los agentes como untrusted. En lo que hay que confiar es en la especificación, y esa no se puede comprobar automáticamente: si está mal, la garantía se debilita sin que nada falle.
Qué verificó AlphaProof Code en el protocolo Signal
AlphaProof Code demostró propiedades de seguridad de las sesiones uno a uno de libsignal, el handshake PQXDH y el Triple Ratchet, sobre el código máquina compilado.
El objetivo fue libsignal-protocol v0.105.4 con spqr v1.6.0, envuelto en una pequeña herramienta de línea de comandos (libsignal-cli) y compilado con rustc estándar a un ejecutable Linux AArch64. Las propiedades demostradas son forward secrecy, seguridad post-compromiso, autenticación y secreto del handshake, y confidencialidad y autenticidad de los mensajes, en dos modelos: el simbólico y el computacional.
Estas son las cifras, todas del paper técnico salvo donde se indica:
| Dato (paper del 10 nov 2026) | Valor |
|---|---|
| Código verificado | ~560 KB, ~140.000 instrucciones AArch64 |
| Pruebas Lean generadas por agentes | ~6,5 millones de líneas |
| Lo que un humano debe leer y confiar | ~26.000 líneas (~18.000 de specs + ~8.000 de semántica AArch64 y nombres de símbolos) |
| Equipo y duración | 5 personas, 4 semanas |
| Agentes por campaña de pruebas | 40 a 80, entre 24 y 72 horas en una sola máquina |
| Código marcado para revisión humana | ~1 %, según el post de DeepMind |
| Modelos | Specs: Gemini 4 Carbon y Claude Opus 5.5. Pruebas: solo Gemini 4 Carbon |
| Referencia histórica | seL4: 20 años-persona. CompCert: 6 |
Divide la segunda fila entre la tercera: unas 250 líneas de prueba por cada línea que un humano tiene que revisar. Esa proporción resume el proyecto.
Para comprobar que las specs no eran decorativas, el equipo reintrodujo dos bugs ya corregidos de libsignal, recompiló y demostró en Lean que esos binarios violaban el teorema de seguridad simbólico. Una spec que no detecta bugs conocidos no sirve de nada.
Por qué en la verificación formal con IA el trabajo humano está en la spec
El paper lo dice sin adornos en la sección 7: "once proofs become cheap, the hard question is what to prove. The majority of our effort went not into proofs but into specifications." Cuando las pruebas salen baratas, la pregunta difícil es qué demostrar.
El proceso es más interesante que las cifras. Quien escribe la spec redacta unos pocos enunciados de alto nivel. Un agente de otra familia de modelos la revisa: si es fiel a la literatura y al código, y si es lo bastante fuerte para descartar bugs conocidos o plausibles. Tras muchas rondas de feedback humano, la spec se aprueba y se congela como objetivo de los agentes de prueba.
Lo más revelador: escribir specs contra código real destapó errores en análisis publicados. El equipo documenta 15 huecos o bugs en el análisis computacional del Double Ratchet que usaron como referencia, y consultas ProVerif de otro paper que, tal como están impresas, hacen falsa la forward secrecy del receptor. Eran especificaciones revisadas por pares, y estaban mal.
Este es el mismo patrón que defiendo para revisar código de agentes. El agente genera mucho, un comprobador determinista decide qué pasa y tú escribes y revisas el contrato. Lo explico paso a paso en Revisión por Contrato, y es la tesis del libro de Spec-Driven Development: la especificación es el artefacto que no puedes delegar.
Qué se discute en Hacker News sobre AlphaProof Code
El hilo de Hacker News del anuncio sumaba 679 puntos y 197 comentarios el 16 de noviembre de 2026. El subhilo que encabeza la discusión no debate si la IA sabe demostrar. Debate la spec.
Lo abre hedora con una sospecha basada en su experiencia: "I've had Claude formally verify crypto and data storage formats. It wrote theorems that looked fine and the formal verification passed but the resulting code contained many, many bugs." Los teoremas parecían correctos, la verificación pasaba y el código tenía muchísimos bugs.
El usuario fooker lo resumió así: "You'd just move from bugs in code to bugs in the spec." Y añadió: "AI will happily change the spec for you so the code verifies though, but that doesn't solve the trust issue." Es decir: pasas de bugs en el código a bugs en la spec, y la IA cambiará la spec encantada para que el código verifique.
En el mismo subhilo, cortesoft recordó que eso vale para cualquier verificación formal: "You can only formally prove that code does what a spec says". Y pyrale dejó la pregunta que deberías hacer ante cualquier anuncio así: "the first question you should ask is what was proven."
Estoy de acuerdo con los cuatro, y por eso el diseño de DeepMind es la lección correcta: la spec se congela antes de que trabajen los agentes de prueba. Si el agente que tiene que hacer pasar algo puede editar ese algo, no tienes verificación: tienes teatro.
Límites: lo que la verificación formal con IA no garantiza
La spec puede estar mal. Es el límite principal y el propio paper lo demuestra encontrando errores en specs publicadas. Una prueba en Lean garantiza que el binario cumple los teoremas, no que los teoremas digan lo que necesitas.
Todo descansa en supuestos. El modelo simbólico idealiza las primitivas criptográficas: los hashes nunca colisionan y las firmas no se falsifican sin la clave. El computacional asume la seguridad de Gap-DH, XEdDSA, Kyber1024 (resistencia a colisiones), HKDF y HMAC (como PRF/PRG) y AES-CBC con HMAC. Además se confía en el kernel de Lean, en la semántica AArch64 y en los contratos de algunas rutinas de bajo nivel.
El alcance es estrecho y explícito. Según el paper quedan fuera los grupos, el estado multidispositivo, la generación de claves (keygen no se verifica), los canales laterales y la recuperación post-cuántica que promete SPQR. El teorema computacional no da garantías contra un atacante cuántico, y su cota deja de decir nada en sesiones de unos 25.000 mensajes si casi cada mensaje abre una nueva época.
No es la app. Lo verificado es una librería dentro de un ejecutable de prueba. Variantes del protocolo se usan en WhatsApp, Messenger y Google Messages, pero esas apps no son el objeto de la verificación.
Verificación formal con IA a escala de un developer normal
No necesitas Lean para aplicar la lección de la verificación formal con IA. Necesitas el mismo reparto de papeles: el agente genera, algo determinista decide y tú escribes lo que hay que cumplir. Esta escala va de lo más barato a lo más fuerte:
| Técnica | Quién decide si vale | Qué escribes tú | Qué no cubre |
|---|---|---|---|
| Tipos estrictos y branded types | El compilador | Los tipos del dominio | Lógica y valores en runtime |
| Property-based testing | El runner, con 100 casos aleatorios por defecto | Las propiedades | Solo muestrea, no demuestra |
| Mutation testing | Stryker | Nada nuevo: mide tus tests | Lo que los tests no preguntan |
| Contrato revisado + CI | El pipeline | Criterios de aceptación y tests congelados | Lo que el contrato olvidó |
| Prueba formal (Lean, Dafny) | El verificador (kernel de Lean; Z3 en Dafny) | Teoremas y supuestos | Lo que la spec no dice |
Un ejemplo con fast-check. La propiedad es tu spec: la escribes tú y el agente no puede tocarla.
import { test } from 39;vitest39;;
import fc from 39;fast-check39;;
import { applyDiscount } from 39;./pricing39;; // implementación generada por el agente
// Spec escrita y revisada por un humano. Fuera del alcance de escritura del agente.
test(39;un descuento nunca deja el precio negativo ni lo sube39;, () => {
fc.assert(
fc.property(
fc.integer({ min: 0, max: 1_000_000 }), // precio en centavos
fc.integer({ min: 0, max: 100 }), // porcentaje
(price, pct) => {
const result = applyDiscount(price, pct);
return result >= 0 && result <= price;
}
)
);
});
Esto no es una prueba formal: prueba 100 entradas aleatorias por defecto (más si subes numRuns), no todas. Pero tiene la misma forma. Bloquea la escritura de ese directorio en los permisos del agente y el comentario de fooker se convierte en regla. En Claude Code basta con una regla de denegación en .claude/settings.json:
{ "permissions": { "deny": ["Edit(./tests/spec/**)"] } }
Ojo: la regla bloquea las herramientas de edición del agente, no un script de Node o Python que abra el archivo por su cuenta. Para un bloqueo a nivel de sistema, la documentación de permisos remite al sandbox. Montar ese circuito con Claude Code de punta a punta es lo que hacemos en Construye con IA.
Lo que te llevas de AlphaProof Code
Elige una función que haya escrito un agente esta semana y escribe, antes de mirar el código, dos propiedades que siempre deban cumplirse. Ponlas en un archivo que el agente no pueda editar. Si las propiedades fallan, has encontrado un bug. Si no se te ocurre ninguna, has encontrado algo peor: no sabías qué tenía que hacer ese código.
Esa es la habilidad que DeepMind acaba de señalar como cuello de botella. Si prefieres empezar por algo gratis, el ebook El Developer Agéntico explica cómo construir agentes de IA desde cero. Para practicarla con método, en el workshop SDD + Agentic Engineering trabajamos specs, contratos y revisión de lo que generan los agentes.
Preguntas frecuentes
¿Qué es AlphaProof Code?
Es un framework multiagente de Google DeepMind, presentado el 10 de noviembre de 2026, para especificar y verificar software en Lean. Los humanos deciden qué demostrar y aprueban la especificación; equipos de agentes generan las pruebas y el kernel de Lean las acepta solo si son correctas.
¿AlphaProof Code demuestra que Signal no tiene bugs?
No. Demuestra que el binario de libsignal v0.105.4 cumple unos teoremas de seguridad concretos en sesiones uno a uno, bajo supuestos explícitos. Grupos, multidispositivo, generación de claves y canales laterales quedan fuera, y tampoco cubre las apps.
¿Qué modelos de IA usó DeepMind?
Según el paper, las especificaciones se escribieron con agentes basados en Gemini 4 Carbon y Claude Opus 5.5, y las pruebas las generaron en exclusiva agentes basados en Gemini 4 Carbon. Ninguno de los autores escribió código de prueba.
¿Puedo usar AlphaProof Code en mi proyecto?
No hay producto ni API anunciados. DeepMind ha publicado las especificaciones y las pruebas en GitHub para que cualquiera las revise, pero no el framework como herramienta.
¿Qué diferencia hay entre verificación formal y property-based testing?
La verificación formal demuestra una propiedad para todas las entradas posibles; el property-based testing la comprueba en una muestra de entradas aleatorias (100 por defecto en fast-check). Las dos dependen de que la propiedad esté bien escrita.
¿La verificación formal con IA sustituye a los tests?
No. Demuestra lo que dice la especificación y nada más: en el caso de Signal quedan fuera los grupos, el estado multidispositivo, la generación de claves y los canales laterales. Los tipos, los tests y el property-based testing siguen cubriendo lo que la spec no formaliza, y son mucho más baratos de escribir.
Por Bezael Pérez — Developer senior con más de 15 años de experiencia y fundador de Dominicode.
¿Quieres construir con agentes en serio?
Curso «Construye con IA» con Claude Code, de la idea al producto.
Developer con más de 15 años en frontend y creador de Dominicode. Escribe sobre IA aplicada al desarrollo de software.
¿Te resultó útil este artículo?
Compártelo con tu comunidad y ayuda a otros desarrolladores.