💻 computer science

A Graded Modal Dependent Type Theory with Erasure, Formalized

Este artículo presenta y formaliza en Agda una teoría de tipos dependientes modales graduada que, mediante un sistema de grados basado en semianillos parcialmente ordenados, permite rastrear el uso de variables para garantizar propiedades como la eliminación de código, y demuestra sus propiedades meta-teóricas junto con la corrección de una función de extracción que traduce términos a un cálculo lambda no tipado eliminando el contenido marcado como eliminable.

Autores originales: Andreas Abel, Nils Anders Danielsson, Oskar Eriksson

Publicado 2026-04-01

📖 5 min de lectura🧠 Análisis profundo

CC BY 4.0

Autores originales: Andreas Abel, Nils Anders Danielsson, Oskar Eriksson

Artículo original bajo licencia CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Esta es una explicación generada por IA del artículo a continuación. No ha sido escrita ni avalada por los autores. Para mayor precisión técnica, consulte el artículo original. Leer descargo de responsabilidad completo

Imagina que estás en una cocina muy sofisticada, donde cada ingrediente tiene una etiqueta especial que dice exactamente cuántas veces puedes usarlo antes de que se agote o se vuelva inútil.

Este artículo de investigación es como el manual de instrucciones para un nuevo tipo de cocina (un lenguaje de programación) que permite a los chefs (programadores) ponerle etiquetas de "grado" a sus ingredientes. El objetivo principal es dos cosas: asegurar que no se desperdicien recursos y poder tirar a la basura lo que no se necesita antes de cocinar el plato final.

Aquí te explico los conceptos clave con analogías sencillas:

1. Las Etiquetas de "Grado" (Las Grades)

En la programación normal, una variable es como un ingrediente que puedes usar tantas veces como quieras. Pero en este nuevo sistema, cada ingrediente tiene una etiqueta numérica (un "grado") que dice:

0: "¡No me uses! Soy solo para la teoría, no me necesitas en la cocina real." (Esto se llama borrado o erasure).
1: "Úsame exactamente una vez." (Como un huevo: si lo usas, se rompe y no queda para otra receta).
Muchos (∞): "Úsame todo lo que quieras."

La analogía: Imagina que estás escribiendo una receta.

Si escribes "agrega 2 huevos", esos huevos son reales (grado 1 o más).
Si escribes "agrega una nota mental de que la receta es para 4 personas", esa nota es irrelevante para la cocina (grado 0). No necesitas la nota para batir los huevos, así que el sistema te permite borrarla antes de empezar a cocinar.

2. El Gran Problema: ¿Qué pasa con lo que tiramos?

El mayor desafío de este sistema es: Si borramos partes del código que dicen "esto es irrelevante", ¿el programa sigue funcionando igual?

Imagina que tienes un robot que sigue una receta.

Versión A: El robot lee la receta completa, incluyendo las notas sobre "para quién es el plato".
Versión B (Borrada): El robot solo lee los pasos de "batir, hornear, servir".

Los autores demuestran matemáticamente que, si sigues las reglas de sus etiquetas, el robot en la Versión B hará exactamente el mismo plato que el de la Versión A. No importa que hayas quitado las notas; el resultado final (el sabor, o en este caso, el número o dato final) es idéntico.

3. Los Tipos de "Pares" (Σ-types)

El sistema tiene dos formas de empaquetar ingredientes juntos, como poner dos cosas en una caja:

La caja fuerte (Strong): Si abres la caja, tienes que usar ambos ingredientes. Si uno se rompe, la caja entera se arruina. Es como un candado de dos llaves.
La caja débil (Weak): Puedes abrir la caja y usar solo lo que necesitas, o incluso ignorar uno de los ingredientes si la etiqueta dice que es "borrable".

La analogía:

Caja Fuerte: Como un matrimonio. Si te divorcias (pierdes una parte), el estado cambia drásticamente.
Caja Débil: Como una caja de herramientas. Si tienes un martillo y un destornillador, pero solo necesitas el destornillador, puedes tirar el martillo a la basura sin que la caja deje de funcionar.

4. La Magia de la "Lógica Relacional"

Para probar que su sistema es seguro, los autores no solo miraron el código, sino que crearon un espejo mágico.

Tienen el código original (con todas las etiquetas y notas).
Tienen el código "borrado" (sin las notas, solo la acción).
Usaron una técnica llamada "relación lógica" para demostrar que, paso a paso, el código original y el código borrado caminan juntos hacia el mismo resultado. Es como tener dos bailarines: uno lleva un traje pesado con muchas capas (el código original) y el otro lleva ropa de gimnasio (el código borrado). El sistema demuestra que, aunque uno pesa más, ambos llegan a la misma posición final al mismo tiempo.

5. ¿Por qué es útil esto?

Eficiencia: Los ordenadores no tienen que gastar energía procesando cosas que no van a usar (como las notas al margen de una receta).
Seguridad: Asegura que no estás usando un ingrediente dos veces cuando solo tenías uno (como en la programación lineal, donde si usas un recurso, se gasta).
Confianza: Al estar todo escrito y probado en un lenguaje llamado Agda (que es como un verificador de matemáticas automático), los autores dicen: "No confíen en nosotros, confíen en las matemáticas que hemos escrito en el ordenador".

En resumen

Este paper presenta un sistema de gestión de recursos para el código que permite a los programadores marcar qué partes de su programa son "basura" (no necesarias para el cálculo final) y borrarlas de forma segura.

Es como tener un reciclador inteligente que, antes de que empiece la obra, revisa los planos y dice: "Oye, esta viga de soporte es solo para que el arquitecto sepa cómo se construyó, pero no la necesitamos para que el edificio se mantenga en pie. Vamos a quitarla". Y lo mejor: el edificio no se cae.

Los autores han construido este sistema, lo han probado hasta el último detalle con matemáticas rigurosas y han demostrado que funciona incluso en situaciones complejas, como cuando hay variables "abiertas" (ingredientes que aún no han llegado a la cocina).

1. El Problema

Las lenguas de programación con tipos fuertes a menudo requieren análisis estáticos para determinar cómo se utilizan las variables (por ejemplo, si son irrelevantes para la ejecución, si son lineales o si fluyen información confidencial). Aunque existen teorías como la Quantitative Type Theory (QTT) que utilizan semianillos para rastrear el uso de recursos, muchos enfoques carecen de una formalización completa de la metateoría en sistemas de tipos dependientes con eliminación grande (large elimination) y universos.

Los desafíos específicos abordados en este trabajo incluyen:

Borrado (Erasure): Garantizar que los argumentos de funciones marcados como irrelevantes para la ejecución puedan eliminarse durante la compilación sin alterar el comportamiento del programa.
Contextos Abiertos: Probar la corrección del borrado no solo para programas cerrados, sino también para programas abiertos que dependen de axiomas o hipótesis irrelevantes, siempre que el contexto sea consistente.
Complejidad Metateórica: Demostrar propiedades clave como reducción del sujeto (subject reduction), normalización y decidibilidad de la igualdad definicional en un sistema con tipos dependientes y grados (grades).
Correspondencia Semántica: Establecer una relación lógica entre el sistema de tipos fuente y un cálculo lambda no tipado de destino para probar la corrección de la extracción.

2. Metodología

Los autores desarrollan una teoría de tipos dependientes genérica, parametrizada por una estructura de modalidad (un semianillo parcialmente ordenado).

Sistema de Tipos ( $\lambda\Sigma\Pi\mathbb{N}^U_M$ ):
- Incluye tipos $\Pi$ , $\Sigma$ fuertes y débiles, números naturales ( $\mathbb{N}$ ), un tipo vacío ( $\bot$ ) y un universo ( $U$ ).
- Utiliza grados (elementos de un semianillo $M$ ) para anotar el uso de variables tanto en términos como en tipos.
- Distingue entre pares fuertes ( $\&$ ) y débiles ( $\otimes$ ), donde los fuertes tienen proyecciones y igualdad $\eta$ , mientras que los débiles usan eliminadores (prodrec).
- Introduce una relación de uso ( $\gamma \triangleright t$ ) separada de la relación de tipado, que asigna grados a las variables libres de un término.
Formalización en Agda:
- Todo el trabajo está formalizado en Agda (aprox. 110,000 líneas de código), basándose en trabajos previos de Abel et al. (2017).
- Se utiliza una relación lógica de Kripke como núcleo para probar las propiedades metateóricas.
Prueba de Corrección del Borrado:
- Se define una función de extracción que traduce términos del sistema fuente a un cálculo lambda no tipado (con semántica estricta y no estricta).
- Se prueba la sonoridad de la extracción mediante una relación lógica de borrado. Esta relación conecta términos fuente con términos destino, demostrando que si un término fuente tiene un valor (ej. un número natural), el término extraído tiene el mismo valor.
- Se manejan casos complejos como emparejamientos borrados (erased matches) en tipos $\Sigma$ débiles, imponiendo restricciones para evitar que programas abiertos se queden atascados (stuck) en ramas imposibles.

3. Contribuciones Clave

Extensión de la Estructura de Modalidades:
- Se introduce una función nr (natural recursion) de 5 argumentos para manejar la recursión en números naturales. Esto refina trabajos anteriores que usaban operadores de estrella (star-semirings), permitiendo una asignación de grados más flexible y correcta para la recursión en diferentes instancias (como tipos lineales o afines).
Formalización Completa de la Metateoría:
- Es, hasta donde se sabe, la primera formalización completa de la metateoría de una teoría de tipos dependiente graduada con un universo y eliminación grande.
- Se prueban: reducción del sujeto, consistencia, normalización fuerte y decidibilidad de la igualdad definicional.
Juicio de Asignación de Grados:
- Se presenta un juicio de uso ( $\gamma \triangleright t$ ) que clasifica el uso de variables libres. Se demuestra que este juicio es decidible y que existe un contexto de uso "principal" (principality) que es el más específico posible para un término dado.
Prueba de Sonoridad del Borrado:
- Se demuestra formalmente que la eliminación de partes marcadas con grado 0 (irrelevantes) preserva el comportamiento computacional.
- Innovación: La prueba es válida para programas abiertos, siempre que todas las variables libres sean marcadas como borrables y el contexto sea consistente (no contenga pruebas del tipo vacío).
Extensiones y Casos de Uso:
- Tipos Unitarios: Se implementan tipos unitarios fuertes y débiles con sus reglas de uso correspondientes.
- Tipos $\Sigma$ Graduados: Se extiende el sistema para soportar tipos $\Sigma$ donde el primer componente tiene un grado específico, permitiendo modelar estructuras de datos con campos borrados (ej. pruebas de invariantes).
- Interpretación de Flujo de Información: El marco se aplica no solo al borrado, sino también al análisis de flujo de información (security levels), donde los grados representan niveles de confidencialidad.

4. Resultados

Corrección Formal: Todas las propiedades metateóricas y la sonoridad de la extracción están verificadas mecánicamente en Agda.
Comportamiento de la Extracción:
- Para la semántica no estricta (call-by-name), el código borrado se extrae a un término de bucle infinito ( $\Omega$ ) para indicar que no se evalúa.
- Para la semántica estricta (call-by-value), el código borrado se reemplaza por un valor dummy ( $\bot$ ).
- Se demuestra que los programas que calculan números naturales producen el mismo resultado numérico antes y después de la extracción.
Limitaciones de los Emparejamientos Borrados: Se identifica que permitir el emparejamiento de pares débiles borrados en posiciones no borradas rompe la propiedad de canonicidad para programas abiertos. El sistema permite desactivar esta característica mediante una condición lateral configurable.

5. Significado e Impacto

Este trabajo es fundamental para el avance de los sistemas de tipos dependientes prácticos (como Agda, Idris o Rocq) por varias razones:

Confianza en la Optimización: Proporciona una base teórica rigurosa para que los compiladores eliminen código irrelevante (borrado) sin comprometer la corrección del programa, incluso en presencia de dependencias complejas.
Generalidad: Al parametrizar la teoría sobre una estructura de semianillo, el marco es aplicable a múltiples dominios: desde la gestión de recursos (linealidad, afinidad) hasta la seguridad (control de flujo de información).
Herramienta para Futuras Investigaciones: La formalización en Agda sirve como un punto de partida verificable para desarrollar verificadores de tipos, inferidores de grados y nuevas extensiones de lenguajes dependientes.
Resolución de Problemas Abiertos: Aborda la dificultad de combinar tipos dependientes con modalidades cuantitativas, ofreciendo soluciones para la recursión y la eliminación grande que anteriormente eran difíciles de formalizar completamente.

En resumen, el artículo establece un estándar de rigor para las teorías de tipos modales graduadas, demostrando que es posible tener un sistema rico y expresivo con garantías formales de corrección para optimizaciones críticas como el borrado de código.