💻 computer science

Are Dependent Types in Set Theory Feasible?

Dit paper beschrijft een mechaniseerde inbedding van afhankelijke types en universums in Tarski-Grothendieck-verzamelingentheorie binnen de Lisa-bewijshulpmiddelen, waarbij een bewijsproducerende bidirectionele typecontrole-tactiek wordt geïmplementeerd om geautomatiseerd redeneren over afhankelijke types mogelijk te maken die volledig is geverifieerd vanuit verzamelingstheoretische axioma's.

Oorspronkelijke auteurs: Yunsong Yang, Simon Guilloud, Viktor Kunčak

Gepubliceerd 2026-03-16

📖 5 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Yunsong Yang, Simon Guilloud, Viktor Kunčak

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

Stel je voor dat wiskunde een enorme, complexe stad is. In deze stad zijn er twee grote wijken die vaak strijd met elkaar voeren over hoe de gebouwen (de bewijzen) het beste ontworpen moeten worden.

De ene wijk is ZFC (de "Stenen Stad"). Dit is gebaseerd op de klassieke verzamelingstheorie. Het is oud, robuust en wordt al meer dan 100 jaar gebruikt. Alles hier is gebouwd op simpele, onbetwiste stenen (verzamelingen). Het nadeel? Het is soms lastig om er complexe, moderne architectuur in te bouwen zonder dat het hele fundament begint te trillen.

De andere wijk is Type Theory (de "Lego-Stad"). Dit is waar moderne tools zoals Lean en Rocq wonen. Hier zijn de blokken (typen) slim ontworpen: ze passen alleen op elkaar als ze precies bij elkaar horen. Dit maakt het bouwen van complexe structuren (bewijzen) veel makkelijker en veiliger, maar het vereist een heel nieuw, ingewikkeld soort bouwvoorschriften die moeilijk te controleren zijn.

Wat doen de auteurs van dit papier?
De onderzoekers Yunsong Yang, Simon Guilloud en Viktor Kunčak hebben een brug gebouwd tussen deze twee wijken. Ze hebben een manier bedacht om de slimme "Lego-blokken" van de Type Theory te bouwen binnen de "Stenen Stad" van de verzamelingstheorie.

Hier is hoe ze dat doen, vertaald naar alledaagse taal:

1. De Vertaalmachine (De Embedding)

Stel je voor dat je een boek in een vreemde taal (Type Theory) hebt, maar je wilt het laten controleren door een lezer die alleen een heel simpele taal spreekt (Eerste-orde logica/Verzamelingstheorie).
De auteurs hebben een vertaalmachine gemaakt. Deze machine neemt de complexe regels van de Type Theory en vertaalt ze naar simpele verzamelingen.

In de Type Theory heb je een functie die alleen werkt als de invoer een bepaald type heeft.
In hun vertaling wordt die functie simpelweg een verzameling van paren (invoer, uitvoer). Als de invoer in de juiste "doos" (verzameling) zit, dan is het goed.
Ze gebruiken een slimme truc (genaamd $\lambda$ FOL) om de "functies" en "variabelen" die in de Type Theory voorkomen, te vertalen naar simpele wiskundige objecten die de Stenen Stad begrijpt.

2. De Onuitputtelijke Lijstjes (Universes)

Een groot probleem in de Stenen Stad is dat je niet oneindig grote lijsten kunt maken. Als je een lijst van alle lijsten maakt, krijg je een paradox (een oneindige lus). In de Type Theory hebben ze echter "niveaus" (universes) om dit op te lossen: Type 1 zit in Type 2, Type 2 zit in Type 3, enzovoort.
Om dit in de Stenen Stad na te bootsen, gebruiken de auteurs een wiskundig hulpmiddel genaamd Tarski's axioma.

De Analogie: Stel je voor dat je een doos hebt. Normaal gesproken kun je niet een doos in een doos doen die alles bevat. Maar Tarski's axioma zegt: "Er bestaat een magische doos (een Grothendieck-universum) die groot genoeg is om alle andere doosjes in te doen, en die zelf ook weer in een nog grotere magische doos past."
Hierdoor kunnen ze die oneindige trap van niveaus (universes) bouwen zonder dat de logica instort.

3. De Automatische Bouwmeester (Proof Generation)

Het mooie aan hun werk is dat ze niet alleen de theorie hebben bedacht, maar ook een automatische bouwmeester (een computerprogramma) hebben gemaakt.

Als een gebruiker zegt: "Bouw een functie die een getal omzet in een tekst", dan kijkt de bouwmeester niet alleen of het lukt, maar schrijft hij ook het bewijs op dat het wel degelijk lukt.
Hij gebruikt een slimme strategie (bidirectioneel type-checking): hij kijkt zowel naar wat er in de doos moet (de invoer) als wat er uit moet komen (de uitvoer).
Als het past, geeft hij een certificaat (een bewijs) dat door de simpele "Stenen Stad" kan worden gecontroleerd. Dit betekent dat je geen vertrouwen hoeft te hebben in complexe software, maar alleen in de simpele, oude wiskundige regels.

4. Een Praktijkvoorbeeld: De Koppeling

In het papier laten ze zien hoe je twee functies aan elkaar kunt plakken (compositie).

Stel je hebt een machine die appels in appelsap verandert ( $A \to B$ ).
En je hebt een machine die appelsap in flessen doet ( $B \to C$ ).
Je wilt een nieuwe machine die appels direct in flessen doet ( $A \to C$ ).
In de Type Theory is dit lastig te bewijzen als de machines heel complex zijn. Maar hun systeem vertaalt dit naar verzamelingen, bewijst dat de uitgang van de eerste machine precies past in de ingang van de tweede, en genereert automatisch het bewijs dat de nieuwe machine werkt.

Waarom is dit belangrijk?

Betrouwbaarheid: Omdat alles uiteindelijk terugvalt op de simpele, oude regels van de verzamelingstheorie, zijn de bewijzen extreem betrouwbaar. Er is minder kans op bugs in de "kern" van het systeem.
Samenwerking: Het maakt het makkelijker om bewijzen te verplaatsen tussen verschillende systemen. Je kunt een bewijs maken in een modern systeem (zoals Lean) en het vertalen naar dit simpele systeem om het te verifiëren.
Toekomst: Het is een eerste stap om de krachtige, moderne tools van wiskundigen (die vaak Type Theory gebruiken) te laten werken op de robuuste, klassieke fundamenten van de wiskunde.

Kortom: De auteurs hebben een vertaalboek en een automatische bouwmeester bedacht die het mogelijk maken om de slimme, moderne architectuur van de Type Theory te bouwen op de solide, oude fundering van de verzamelingstheorie, zonder dat je de complexe regels van de moderne architectuur zelf hoeft te begrijpen om het te controleren.

Probleemstelling

Hoewel Zermelo-Fraenkel verzamelingstheorie met het keuzeaxioma (ZFC) al meer dan een eeuw de standaardgrondslag voor wiskunde vormt, wordt het landschap van interactieve stellingbewijzers (zoals Rocq en Lean 4) gedomineerd door systemen gebaseerd op afhankelijke type-theorie (DTT). Hoewel DTT-systemen praktische voordelen bieden, zoals ingebouwde berekening en voorspelbaar type-checken, zijn hun logische kernen complexer om te implementeren en te valideren dan eerste-orde logica met ZFC-axioma's. Dit leidt tot grotere kernen, complexere deductieregels en meer implementatiefouten.

Er is een behoefte aan het ontwikkelen van DTT-functies binnen bewijsassistenten gebaseerd op verzamelingstheorie om:

De betrouwbaarheid te vergroten door te bouwen op een eenvoudiger, goed onderzochte fundamentele laag (eerste-orde logica).
Interoperabiliteit tussen bewijsassistenten te faciliteren (bijvoorbeeld het overdragen van bewijzen van Lean 4 naar een verzamelingstheoretisch systeem).
Te onderzoeken of afhankelijke types kunnen worden gerealiseerd als een "zacht typesysteem" (soft type system) bovenop een verzamelingstheoretische basis, zonder de complexiteit van een volledige type-theoretische kern te hoeven implementeren.

Methodologie

De auteurs presenteren een mechanische embeding van afhankelijke functietypes met een hiërarchie van universa in schematische eerste-orde logica met gelijkheid, gebruikmakend van de axioma's van Tarski-Grothendieck verzamelingstheorie. Dit wordt geïmplementeerd in de bewijsassistent Lisa.

De kern van de aanpak bestaat uit de volgende stappen:

Embedding in $\lambda$ FOL:
Omdat eerste-orde logica geen directe $\lambda$ -binding toestaat, maken de auteurs gebruik van $\lambda$ FOL (Lambda First-Order Logic), een extensie van Lisa die $\lambda$ -termen en Hilbert's $\epsilon$ -operator ondersteunt.
- Types als Mengen: Types worden gemodelleerd als verzamelingen.
- Afhankelijke Producten ( $\Pi$ ): Een afhankelijke producttype $\Pi x:T_1. T_2$ wordt vertaald naar de verzameling van functies $f$ die een functionele relatie vormen met domein $T_1$ , waarbij voor elke $x \in T_1$ , de waarde $f(x)$ in de verzameling $T_2(x)$ zit.
- Abstractie en Applicatie:
  - Abstractie ( $\lambda x:T. u$ ) wordt gemodelleerd als de verzameling van paren $\{(x, u(x)) \mid x \in T\}$ .
  - Applicatie ( $t\ u$ ) wordt gedefinieerd via de $\epsilon$ -operator: $\epsilon y. (u, y) \in t$ . Dit selecteert een waarde die voldoet aan de relatie.
Beheer van Universa (Universes):
Standaard ZFC biedt geen interne hiërarchie van universa die gesloten is onder alle verzamelingstheoretische constructies (zoals het $\Pi$ -operator). Om dit op te lossen, maken de auteurs gebruik van Tarski's axioma, dat de existentie van oneindig veel Grothendieck-universa garandeert.
- Een Grothendieck-universum is een verzameling die gesloten is onder paren, vereniging, machtsverzamelingen en vervanging.
- Ze definiëren een predicaat isUniverse dat vereenvoudigt is tot de nodige eigenschappen voor afhankelijke producten.
- Een hiërarchie van universa wordt opgebouwd door iteratief een universum te kiezen dat een gegeven verzameling bevat (universeOf).
Bidirectioneel Type-checken met Bewijsproductie:
De auteurs implementeren een tactic genaamd Typecheck.prove die bidirectioneel type-checking (checken en infereren) uitvoert. In tegenstelling tot traditionele type-checkers die alleen een boolean of een type retourneren, construeert deze tactic een formeel bewijsobject dat door de Lisa-kern kan worden geverifieerd.
- Check-modus: Controleert of een term een verwacht type heeft.
- Infer-modus: Leidt het type van een term af.
- Subset-modus: Handelt subtyping-relaties af (o.a. covariantie in het codomein).

Belangrijkste Bijdragen

Set-theoretische Realisatie van DTT: Een volledige mechanische embeding van afhankelijke functietypes en universa binnen een op eerste-orde logica gebaseerd systeem (Lisa).
Proof-Producing Type Checker: Een geautomatiseerde tactic die type-checking-judgements omzet in formeel verifieerbare bewijzen gebaseerd op verzamelingstheoretische axioma's.
Ondersteuning voor Subtyping: Een proof-of-concept implementatie van subtyping, specifiek voor covariante functietypes, wat een uitdaging is in verzamelingstheoretische interpretaties (vanwege impredicativiteit).
Formele Correctheid: Alle type-regels (zoals $\beta$ -reductie, Tabs, Tapp) worden bewezen als stellingen binnen de verzamelingstheorie, gebaseerd op de definities van abs, app en Pi.

Resultaten

Correctheid: De auteurs tonen aan dat de gedefinieerde embeding de verwachte $\beta$ -reductie herwint en dat de inferentieregels van afhankelijke type-theorie (zoals het invoeren en elimineren van afhankelijke producten) geldig zijn binnen de verzamelingstheorie.
Geautomatiseerde Redenering: De tactic Typecheck.prove slaagt erin om automatisch bewijzen te genereren voor complexe typings, zoals polymorpe functies (bijvoorbeeld functiesamenstelling comp en de identiteitsfunctie id), waarbij de universe-niveaus correct worden beheerd via cumulativiteit.
Subtyping: Het systeem ondersteunt subtyping voor functies met een invariant domein en een covariant codomein. De auteurs tonen aan dat volledige contra-variatie (zoals in veel programmeertalen) niet direct vertaalbaar is naar verzamelingstheorie zonder paradoxen, en bieden een beperkte maar bruikbare variant.

Betekenis en Impact

Dit werk is een belangrijke stap in de richting van interoperabiliteit tussen verschillende bewijsassistenten. Het toont aan dat:

De krachtige features van afhankelijke type-theorie (zoals in Lean 4 en Rocq) kunnen worden gesimuleerd en geverifieerd binnen een eenvoudiger, verzamelingstheoretisch fundament.
Bewijzen die in complexe type-theoretische systemen zijn opgesteld, theoretisch kunnen worden vertaald naar en geverifieerd in systemen met een kleinere, meer robuuste logische kern (zoals Lisa).
Het mogelijk is om "zachte" typesystemen te bouwen bovenop verzamelingstheorie die de gebruiker een type-theoretische interface bieden, terwijl de onderliggende logica puur verzamelingstheoretisch blijft.

Dit biedt een alternatief pad voor de ontwikkeling van toekomstige bewijsassistenten die de balans zoeken tussen de expressiviteit van type-theorie en de eenvoud en betrouwbaarheid van verzamelingstheorie.