Artículos en profundidad sobre la tecnología que da forma al futuro.

Verificando Riemann en Lean: lecciones para ingenieros

Una prueba de 17 millones de líneas en Lean de la Hipótesis de Riemann superó varios verificadores independientes. Esto enseña a los ingenieros.

Una catedral construida con bloques geométricos luminosos entrelazados, que evoca una prueba masiva verificada por máquina.
Una prueba demasiado grande para leerla puede seguir siendo una estructura que puedes inspeccionar, si revisas las uniones y no la pared entera.

El fragmento de ingeniería de software más audaz que se ha publicado últimamente no es un framework, una base de datos ni un agente de IA. Es una prueba. Levent Alpöge publicó una verificación en Lean de la Hipótesis de Riemann como una biblioteca de unas diecisiete millones de líneas de código, y en menos de un día un grupo distribuido de voluntarios la había compilado, había comparado su teorema final con el enunciado canónico de Mathlib y había vuelto a verificar la prueba exportada con varios núcleos independientes, dos de los cuales incluyen argumentos verificados por máquina de que no pueden aceptar una prueba falsa.

Aquí va mi afirmación polémica, que voy a defender y luego matizar en parte: este es el acontecimiento más importante en lenguajes de programación de esta década, y casi no tiene nada que ver con la teoría de números. La Hipótesis de Riemann es casi irrelevante. Lo que importa es que ahora tenemos un ejemplo real, a escala de investigación genuina, de un problema que los ingenieros de software rodean constantemente sin comprometerse nunca: ¿cómo se construye un artefacto tan grande que ningún ser humano puede revisarlo, pero tan rigurosamente comprobado que desconocidos están dispuestos a jugarse su reputación profesional con él?

Qué significan realmente diecisiete millones de líneas de verificación en Lean

Lean se basa en una idea que Nicolaas de Bruijn desarrolló a finales de los años sesenta con Automath, uno de los primeros sistemas para codificar matemáticas de forma verificable por máquina. Hoy se conoce como el criterio de de Bruijn: un asistente de pruebas debe producir objetos de prueba que un programa verificador pequeño e independiente pueda comprobar por sí solo. La parte grande e ingeniosa del sistema, es decir, el elaborador, el motor de tácticas y la automatización que convierte scripts de prueba escritos para humanos en objetos formales, es explícitamente no confiable. Es un compilador, y como cualquier compilador, puede tener errores. La confianza reside en el núcleo, un programa pequeño que comprueba completamente los términos de prueba ya elaborados según las reglas de la lógica.

Esa arquitectura es exactamente lo que hace significativo un artefacto de diecisiete millones de líneas. Nadie leyó esa prueba. Nadie podría. Tiene el tamaño de un componente importante de un sistema operativo y está en gran parte generada y moldeada por máquinas. Pero el flujo de verificación la trata como un buen sistema de construcción trata un binario compilado: decenas de personas compilaron la biblioteca de forma independiente y reprodujeron el mismo archivo de exportación de prueba en bruto, byte a byte. Eso es una compilación hermética y determinista que produce un artefacto direccionable por contenido, y entonces empieza lo interesante, porque lo que consumen los verificadores es el artefacto, no el código fuente.

Una prueba que no puedes leer puede seguir siendo una prueba en la que puedes confiar. Esa inversión de la revisión de código habitual es toda la historia.

La gente del software debería detenerse un momento en esa inversión. Nuestro mecanismo estándar de garantía es que una persona abra un diff y lo mire con el ceño fruncido. Eso escala hasta quizá unos pocos miles de líneas por revisor a la semana, antes de que el ceño fruncido se convierta en teatro. La respuesta de la comunidad de Lean es bajar la confianza en la pila: confiar en un núcleo pequeño, confiar en la diversidad de reimplementaciones independientes de ese núcleo y tratar todo lo que está encima, por muchos millones de líneas que sean, como datos que hay que comprobar y no como prosa que hay que revisar. Eso no es un truco matemático. Es una postura de ingeniería.

El problema del enunciado: demostrar el teorema correcto

Lo primero que comprobó la comunidad no fue la prueba, sino el enunciado. Esta es la parte que los externos subestiman sistemáticamente, y es donde los proyectos de formalización mueren en silencio. Un asistente de pruebas te dejará demostrar lo incorrecto con total rigor, porque la lógica no se preocupa por lo que quisiste decir. El ejemplo de juguete clásico es una rutina de ordenación verificada cuya especificación dice que la salida está ordenada pero olvida decir que es una permutación de la entrada. La lista vacía está maravillosamente ordenada. La prueba pasa. La función es basura.

Así que la certificación de este trabajo descansa sobre un hecho que es fácil pasar por alto: el enunciado RiemannHypothesis ya vivía en Mathlib, donde lo habían examinado personas que conocen bien tanto la teoría analítica de números como las convenciones de codificación de Lean: dónde pueden estar los ceros, cómo se excluyen los ceros triviales, sobre qué está definida realmente la función. Después, la comunidad añadió un archivo que aísla exactamente ese enunciado, que solo importa Mathlib, y usó dos herramientas independientes (comparator y con-leche --compare) para confirmar que el teorema que demuestra la biblioteca de Alpöge es exactamente ese enunciado, no una aproximación ni un parecido definicional con una hipótesis relajada que se ha eliminado discretamente. Ya he defendido antes que la brecha entre especificación e implementación es donde viven los errores, y las matemáticas formales son el lugar donde esa verdad deja de ser una entrada de blog y se convierte en un punto de checklist con herramientas dedicadas.

Fíjate en lo inusual que es esta disciplina según los estándares de la industria. ¿Cuándo fue la última vez que viste a un equipo construir una herramienta dedicada cuyo único trabajo fuera demostrar que lo que hace su sistema es lo que dice el contrato? Escribimos tests que muestrean el contrato. Escribimos firmas de tipos que lo insinúan. La comunidad de Lean construyó comparadores que lo identifican. Si te llevas una sola práctica de todo este asunto, que sea esa: antes de celebrar que la máquina comprobó tu prueba, comprueba que la máquina está comprobando tu afirmación.

Dos llaves de latón casi idénticas bajo una lupa, una encaja en la cerradura y la otra está sutilmente desajustada.
Una prueba de un enunciado casi correcto es como una llave que difiere en un solo diente: impresionante e inútil.

Confianza en el núcleo y ecosistema de verificadores

El núcleo oficial de Lean es pequeño, pero «pequeño» no es por sí solo un argumento de seguridad: es una invitación a reimplementarlo. La verificación se apoyó con fuerza en esa invitación. La prueba exportada fue comprobada no solo por el núcleo de Lean sino por con-leche y con-ron, además de varios verificadores de terceros escritos en distintos lenguajes de programación, todos consumiendo el mismo archivo de exportación inerte. La palabra inerte importa: los verificadores nunca ejecutan código de los fuentes de la prueba, así que un fragmento malicioso escondido en diecisiete millones de líneas no tiene ningún entorno de ejecución donde actuar. Es la diferencia entre revisar un documento y ejecutar un adjunto.

Los dos peso pesado merecen mención especial, porque con-leche y con-ron vienen cada uno con una prueba formal, relativa a la teoría de conjuntos, de que no pueden aceptar una prueba falsa. Esto cierra la regresión habitual: sí, el núcleo de Lean podría teóricamente tener un error de corrección, así que compruébalo con otro núcleo; sí, ese núcleo también podría tenerlo; pero cuando el argumento de corrección del verificador está a su vez verificado por máquina contra una base distinta, la superficie de ataque se reduce a «un error que sobrevive simultáneamente a través de múltiples implementaciones, múltiples lenguajes y múltiples sistemas fundacionales». No es imposible. No es algo que puedas planificar. He escrito sobre cómo incluso el borrow checker de Rust llegó con un agujero de corrección, así que no digo «confía en el núcleo» a la ligera. La respuesta nunca fue un único componente de confianza. Es una población diversa de verificadores y un formato de prueba compartido y portable: programación de N versiones, que la aviónica lleva décadas practicando, aplicada por fin a la verdad misma.

import Mathlib
-- The statement, maintained and vetted in Mathlib, that the
-- new library proves. Anybody can inspect what the words mean.
#check RiemannHypothesis
-- A trivial kernel-checked proof. The kernel reduces 2 + 2 to 4
-- and accepts rfl; no tactic code runs at check time.
theorem two_add_two : 2 + 2 = 4 := rfl
-- Ask the kernel what this proof's trust base actually is:
#print axioms two_add_two
-- reports that the proof depends on no axioms at all
-- Had someone snuck in `sorry` (Lean's escape hatch) or a custom
-- axiom, this is where it shows up: as `sorryAx` or worse, in
-- the dependency list of the final theorem.

Ese último mecanismo es la pista de auditoría que la mayoría de sistemas no tienen. #print axioms le pregunta al núcleo, a posteriori, en qué supuestos descansa realmente una prueba. Todo atajo en Lean, como sorry, un axioma declarado por el usuario o un unsafe mal usado, deja una huella en esa lista. Imagina que tu build pudiera responder «¿qué diste por supuesto?» con la misma precisión: este servicio asume que el reloj es monótono, este asume TLS 1.3, este asume que la cola entrega al menos una vez. La mayoría de nuestros sistemas tienen exactamente estos supuestos. Casi ninguno puede enumerarlos bajo petición.

Gestión de dependencias a escala Mathlib

Una línea del comunicado de la comunidad es pura poesía de gestión de dependencias: la base de código depende directamente solo de Mathlib. Sin forks vendorizados, sin ramas privadas de la biblioteca estándar, sin parches fuera del árbol. Diecisiete millones de líneas de matemáticas de investigación descansan sobre una única fuente upstream compartida y con integración continua. Eso solo funciona porque Mathlib opera menos como un repositorio de paquetes y más como un organismo de estandarización con CI: revisión agresiva, una caché compartida para que los colaboradores no reconstruyan todo el universo en cada pull, y una cultura en la que subir tus definiciones al proyecto principal es lo habitual y no un favor que le haces a la comunidad.

Y ese orden, primero el enunciado y después la prueba, es lo que los equipos de ingeniería hacen al revés. La definición de la Hipótesis de Riemann se integró, revisó y endureció en la biblioteca compartida antes de que llegara la prueba. Cuando llegó la carga de diecisiete millones de líneas, no había discusión sobre lo que afirmaba: la afirmación ya era infraestructura. Compáralo con cómo la mayoría de las bases de código grandes absorben una contribución enorme: las interfaces las define la propia contribución, la revisión ocurre bajo presión de tiempo y, cuando alguien se da cuenta de que el contrato se ha desviado, otros tres equipos ya dependen de la versión desviada. La disciplina de Mathlib, que consiste en canonizar el vocabulario en público y luego dejar que el trabajo se apoye en él, es exactamente lo que hace un equipo de plataforma sano con sus APIs internas. La diferencia es que de verdad lo hacen.

Brazos robóticos moviendo cajas idénticas selladas con cera por cintas transportadoras en un enorme almacén automatizado.
Un upstream compartido, cada consumidor reconstruyendo el mismo artefacto: la gestión de dependencias como utilidad pública.

Dónde falla la afirmación polémica

Ahora el matiz, porque la afirmación merece una prueba de estrés honesta. Los verificadores independientes no son tan independientes como sugiere la retórica. Comparten una metateoría, varios comparten linaje de diseño, y los autores de los verificadores se hablan entre sí: diversidad de lenguaje de programación no es diversidad de lógica. También hay precedentes de deslizamientos: una refutación fabricada de la conjetura de Collatz llegó a pasar por uno de estos verificadores independientes antes de que alguien la detectara. La formulación honesta del argumento de confianza es la que ofreció un observador cuidadoso: para que la prueba fuera incorrecta, un único error tendría que afectar tanto a las pruebas de consistencia interna de los verificadores como a esta prueba concreta, en todas las implementaciones. Prácticamente nula. Pero «prácticamente nula» es una probabilidad, y el comunicado de la comunidad dice «confianza total», que es sociología.

También hay una pared de carga humana que los cuatro criterios publicados no mencionan. Según todos los relatos, esta prueba se produjo con mucha asistencia de IA, con Alpöge al timón: descomponiendo el problema, reconociendo callejones sin salida y sabiendo qué lemas olían mal. Esa experiencia humana hace un trabajo epistémico real, y el certificado tal como está escrito no se apoya en ella en absoluto, lo cual me incomoda. Ya he cubierto la división entre la generación de conjeturas por LLM y la verificación mecánica de pruebas, y esto es esa división a máxima escala: la máquina propuso a una escala sin precedentes, la máquina verificó a una escala sin precedentes, y una rara persona humana se sentó en la unión haciendo que todo fuera legible. Quitar a ese humano de la historia oficial hace la historia más limpia y menos verdadera.

Lecciones de ingeniería para software verificado por máquina

  • Mantén la base de computación confiable pequeña y aburrida. Cada línea de código que debes confiar es un pasivo; cada línea que solo compruebas es un dato.
  • Exporta a un formato inerte y portable. La verificación debería ejecutarse sobre un documento, no sobre un proceso en vivo que pueda ejecutar sorpresas.
  • Verifica la afirmación, no solo el argumento. Construye el comparador. Demuestra que tu artefacto coincide con el contrato antes de celebrar la prueba.
  • Diversifica tus verificadores de verdad. Los distintos lenguajes ayudan; los distintos fundamentos ayudan más; un solo verificador con una prueba de consistencia vale más que dos que se copian los deberes.
  • Haz las compilaciones reproducibles y los artefactos direccionables por contenido. «Decenas de personas reprodujeron el mismo archivo de exportación» es una frase a la que debería aspirar cualquier pipeline de publicación.
  • Canoniza el vocabulario compartido en el upstream antes de que llegue la gran contribución. Primero las definiciones, después las heroicidades.
  • Enumera tus supuestos de forma mecánica. Si tu sistema no puede responder «¿de qué dependes?», no sabes lo que has desplegado.

Debajo de la lista hay una sola idea: los tests muestrean un espacio, las pruebas lo agotan, y el terreno intermedio (testing basado en propiedades, model checking, ejecución simbólica) es la industria avanzando lentamente y a regañadientes desde el primer campo hacia el segundo. Nadie te pide que formalices tu app CRUD. Pero la frontera de lo que «debe verificarse por máquina» no deja de moverse: primitivas criptográficas, protocolos de consenso, contratos inteligentes, software de vuelo, verificadores eBPF del kernel. Cada una de esas comunidades ha tenido su momento de «deberíamos hacer esto al estilo Lean», normalmente justo después de un incidente caro. La verificación de Riemann demuestra que las herramientas, la cultura y el ecosistema de verificadores pueden soportar el peso de algo genuinamente enorme. Se acabaron las excusas.

Cien años intentándolo

Como persona de lenguajes, no puedo evitar ver esto como el pago de una apuesta muy antigua. Hilbert incluyó la Hipótesis de Riemann en su lista en 1900. De Bruijn inició Automath en 1967. Robin Milner creó ML en los años setenta precisamente como metalenguaje para escribir tácticas de prueba: toda la familia de ML, que pasa por OCaml y Haskell y llega hasta el sistema de tipos de Rust, desciende de herramientas para pruebas verificadas por máquina. El manifiesto QED de los noventa preguntó por qué toda la matemática aún no estaba formalizada y casi todos se encogieron de hombros. Luego el Teorema de los Cuatro Colores entró en Coq, después el teorema de Feit–Thompson, y finalmente el Liquid Tensor Experiment demostró que la matemática de investigación moderna, no solo la clásica, podía sobrevivir al contacto con un núcleo. Cada uno de esos hitos fue calificado de truco de feria por alguien. Cada uno entrenó a la comunidad y endureció la biblioteca sobre la que se apoyó el siguiente.

Entonces, ¿es correcta mi afirmación inicial? En parte. Los matemáticos recibieron un teorema, y para la mañana ya se hacían la pregunta mejor: qué enseña la prueba, algo que diecisiete millones de líneas comprobadas no hacen automáticamente. Los ingenieros recibieron algo más raro: un plano, validado bajo el máximo escrutinio, para construir artefactos demasiado grandes para que cualquier humano los lea, y comprometer aun así el nombre de una comunidad con ellos. La próxima vez que alguien en una revisión de diseño te diga que la verificación real no escala, sabrás exactamente qué registro de compilación enseñarle.