💻 computer science

Formalizing a Many-Sorted Hybrid Polyadic Modal Logic in Lean

Dit artikel presenteert een door de machine gecontroleerde Lean-formalisatie van een algemene veel-gesorteerde hybride polyadische modale logica met een intrinsiek sorteermechanisme en een domeinspecifieke taal, wat een solide en veelzijdige basis biedt voor het specificeren en verifiëren van programmeertalen en beveiligingsprotocollen.

Oorspronkelijke auteurs: Andrei-Alexandru Oltean, Bogdan Macovei, Ioana Leuştean

Gepubliceerd 2026-06-26

📖 5 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Andrei-Alexandru Oltean, Bogdan Macovei, Ioana Leuştean

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 je een architect bent die probeert een universele "logische gereedschapskist" te bouwen die gebruikt kan worden om te controleren of computerprogramma's correct werken, of dat geheime berichten in beveiligingsprotocollen veilig zijn, of dat filosofische argumenten standhouden. Het probleem is dat elke taak een iets andere set gereedschappen vereist, en meestal moet je voor elke nieuwe taak een nieuwe gereedschapskist vanaf nul bouwen.

Dit artikel presenteert een oplossing: een universele, machine-gecontroleerde logische gereedschapskist gebouwd binnen een softwareprogramma genaamd Lean. De auteurs hebben een systeem ontwikkeld dat flexibel genoeg is om complexe, meerlagige regels (many-sorted) te verwerken en tegelijkert de verschillende "toestanden" of "werelden" (hybride logica) kan bekijken.

Hier is een uitsplitsing van hun werk met behulp van alledaagse analogieën:

1. De "Lijst-truc": Bouwen met LEGO-stenen

De grootste uitdaging in dit project was ervoor zorgen dat de regels van de logica automatisch werden gevolgd, zonder dat een mens elke stap handmatig hoefde te controleren.

Het Probleem: In traditionele logica schrijf je misschien een formule en moet je vervolgens een aparte "spellingscontrole" uitvoeren om te zien of het wel klopt (bijv. "Heb je geprobeerd een getal aan een zin toe te voegen?").
De Oplossing (De Lijst-truc): De auteurs behandelden logische formules als lijsten van LEGO-stenen. Ze ontwierpen het systeem zo dat je fysiek niet in staat bent om twee incompatibele stenen aan elkaar te klikken. Als je probeert een "rode" steen (een specifiek type regel) aan een "blauwe" steen (een ander type regel) te koppelen, weigert het systeem simpelweg om ze aan elkaar te klikken.
Waarom dit belangrijk is: Dit betekent dat als een formule in hun systeem bestaat, deze per definitie gegarandeerd correct is. Ze hoeven niet achteraf op fouten te controleren, omdat de structuur zelf fouten voorkomt voordat ze kunnen gebeuren.

2. De "Context"-wijzer: Een speld zoeken in een hooiberg

De logica die zij hebben gebouwd, maakt complexe operaties mogelijk waarbij je een specifiek deel van een lange, ingewikkelde zin wilt veranderen.

De Analogie: Stel je voor dat je een lange paragraaf tekst hebt en je wilt het woord "kat" vervangen door "hond". In een normaal document kun je gewoon zoeken en vervangen. Maar in hun systeem kan er veel "katten" voorkomen, en je moet alleen de kat in de tweede zin veranderen, niet die in de vijfde zin.
De Oplossing: Ze creëerden een digitale "wijzer" (een Context genoemd). Deze wijzer is als een GPS-coördinaat die zegt: "Ik wijs specif eigenlijk naar de 'kat' in de tweede zin." Wanneer ze een regel toepassen, gebruiken ze deze wijzer om precies die specifieke woorden te vervangen, terwijl de rest onveranderd blijft. Hierdoor kunnen ze zeer complexe, meerdelige regels afhandelen zonder in de war te raken.

3. De DSL: Een "Taalvertaler"

Om dit krachtige systeem bruikbaar te maken voor gewone mensen (zoals programmeurs of beveiligingsexperts), hebben de auteurs een Domain-Specific Language (DSL) gebouwd.

De Analogie: Denk aan de kernlogica als een hogere programmeertaal (zoals C++ of Assembly) die erg krachtig maar moeilijk leesbaar is. De DSL is als een vertaler die gebruikers in staat stelt om in een vriendelijke, vertrouwde stijl te schrijven (zoals een recept of een stroomdiagram).
Hoe het werkt: Een gebruiker kan een regel schrijven die lijkt op een standaard computerprogramma (bijv. "Als X, dan doe Y"). Het systeem vertaalt dit automatisch naar de complexe, onderliggende logische stenen. Dit betekent dat gebruikers geen logici hoeven te zijn om het systeem te gebruiken; ze hoeven alleen hun specifieke vakgebied te kennen (zoals programmeren of beveiliging).

4. Drie Praktijktesten

Om te bewijzen dat hun gereedschapskist werkt, hebben ze het gebruikt om drie zeer verschillende problemen op te lossen:

De Programmacontroleur (SMC Machine): Ze gebruikten het systeem om een eenvoudig computerprogramma te verifiëren. Ze vertaalden de stappen van het programma naar hun logica en bewezen dat als je met specifieke getallen begint, het programma definitief met het juiste resultaat eindigt. Het is alsof je een wiskundige vergelijking bewijst voordat je zelfs maar de rekenmachine gebruikt.
De Beveiligingsprotocol-detective (BAN-logica): Ze modelleerden hoe twee mensen geheime sleutels uitwisselen over een netwerk. Ze gebruikten de logica om te bewijzen dat als een bericht versleuteld is met een specifieke sleutel, de ontvanger er 100% zeker van kan zijn wie de afzender is. Ze hebben een beroemd beveiligingsprotocol (Needham-Schroeder) succesvol geverifieerd om aan te tonen dat het systeem potentiële beveiligingsfouten kan opsporen.
De Filosofische Vereenvoudiger (S5-logica): Ze lieten zien dat hun complexe systeem ook de eenvoudige, standaard logica (S5) kan afhandelen. Dit bewijst dat het systeem veelzijdig genoeg is om een "Zwitsers zakmes" te zijn — het kan de meest complexe scenario's met meerdere werelden aan, maar kan ook inkrimpen tot eenvoudige, alledaagse logica indien nodig.

5. De "Soundness"-garantie

De belangrijkste claim van het artikel is Soundness (deugdelijkheid).

De Analogie: Stel je een rechter voor in een rechtszaal. De rechter moet er zeker van zijn dat als hij "Schuldig" zegt, de persoon de misdaad daadwerkelijk heeft gepleegd volgens de wet.
Het Resultaat: De auteurs gebruikten de software Lean om wiskundig te bewijzen dat hun systeem sound is. Dit betekent: Als het systeem zegt dat een bewering waar is, is het wiskundig onmogelijk dat deze onwaar is. Ze hebben niet alleen gegokt; ze hebben een machine-gecontroleerd bewijs gebouwd dat hun regels nooit tot een leugen leiden.

Samenvatting

Kortom, de auteurs hebben een superflexibele, foutbestendige logische motor gebouwd binnen een computerprogramma. Ze hebben een manier gecreëerd waarop gebruikers gemakkelijk hun eigen regels kunnen definiëren, die regels vertalen naar een formaat dat de computer met 100% zekerheid kan verifiëren, en bewezen dat de motor correct werkt voor alles van het controleren van code tot het beveiligen van digitale berichten. Het is een universele vertaler die menselijke ideeën omzet in wiskundig gegarandeerde waarheden.

Technische Samenvatting: Formalisering van een Veel-gesorteerde Hybride Polyadische Modale Logica in Lean

Probleemstelling

Het artikel behandelt de uitdaging van het bieden van een uniforme, wiskundig onderbouwde axiomatische basis voor het specificeren en verifiëren van diverse systemen, zoals programmeertalen en beveiligingsprotocollen. Bestaande formalisaties missen vaak de flexibiliteit om veel-gesorteerde (many-sorted) signaturen (waarbij verschillende typen entiteiten bestaan) en polyadische modale operatoren (operatoren met willekeurige ariteiten) binnen één enkel kader te verwerken. Bovendien is de formalisering van hybride modale logica's (die nominalen en staatsvariabelen bevatten) in proof assistants traditioneel beperkt tot mono-gesorteerde of monadische instellingen, ondanks hun kracht voor het refereren aan specifieke staten. De auteurs streven ernaar deze kloof te overbruggen door een algemeen kader in de Lean proof assistant te creëren dat arbitraire signaturen, polyadische operatoren en hybride kenmerken ondersteunt, terwijl ze ervoor zorgen dat de syntaxis intrinsiek goed gesorteerd is om typefouten tijdens verificatie te voorkomen.

Methodologie

De auteurs implementeren een formalisering van de algemene hybride modale logica $H_\Sigma(@, \forall)$ binnen de afhankelijke typetheorie van Lean. Hun methodologie steunt op drie kerntechnische innovaties:

1. Intrinsieke Sortering via de "List Trick"

Om de noodzaak voor aparte "sort-checking" functies te vermijden, maken de auteurs gebruik van de afhankelijke typen van Lean om sorteringsrestricties op het niveau van de types af te dwingen.

Inductieve Typen: Formules worden gerepresenteerd door een inductief type FormL, geïndexeerd door een List van sorts.
De List Trick: Terwijl standaard formules overeenkomen met singleton-lijsten van sorts, introduceren de auteurs een kunstmatige constructor cons die het mogelijk maakt om lijsten van formules te bouwen die geïndexeerd zijn door niet-singleton lijsten van sorts.
Mechanisme: Modale operatoren zijn gedefinieerd om een lijst met argumenten (de domein-sorts) te nemen en een formule van een specifieke range-sort terug te geven. De typechecker verifieert dat de lijst met argument-sorts exact overeenkomt met de domein-signatuur van de operator. Dit zorgt ervoor dat elke geconstrueerde term per definitie een goed gesorteerde formule is.
Contexten: Om polyadische operatoren en axioma's die betrekking hebben op generieke argumenten (bijv. substitutie binnen een willekeurige argumentpositie van een operator) te verwerken, definiëren de auteurs een inductief type Context. Een Context fungeert als een pointer naar een specifieke instantie van een sub-formule binnen een lijst van formules, wat rigoureuze substitutie mogelijk maakt zonder te vertrouwen op informele "..." notatie.

2. Semantische Formalisering

De semantiek wordt gedefinieerd met behulp van Kripke-frames en modellen die evenehen veel-gesorteerd zijn.

Werelden: Een frame brengt elke sort in kaart naar een type in een universum.
Toegankelijkheidsrelaties: Relaties worden gedefinieerd als verzamelingen van WProd (een producttype geconstrueerd uit de lijst van sorts), die tupels van werelden vertegenwoordigen die aan de relatie voldoen.
Verzadiging (Satisfaction): De verzadigingsrelatie wordt recursief gedefinieerd. De "list trick" vereenvoudigt de afhandeling van polyadische operatoren: de verzadiging van een lijst met argumenten wordt gedefinieerd als de gelijktijdige verzadiging van de lijst op een product van werelden.

3. Axiomatische Extensies en Bewijsysteem

Het bewijsysteem is parametrisch over een axiomatische extensie $\Lambda$ .

Axioma-sets: Axioma's worden gedefinieerd als S-gesorteerde verzamelingen van formules.
Inductieve Bewijzen: Het Proof type is een inductieve familie. Cruciaal is dat de auteurs inductieve typen gebruiken om axioma-schema's te definiëren. In plaats van oneindige instanties handmatig op te sommen, definiëren zij een inductieve familie van axioma's (bijv. voor de SMC machine of BAN-logica) waarbij de constructors schema-patronen representeren. De verzameling stellingen is vervolgens de afsluiting van deze schema's onder deductieregels.
Soundness (Correctheid): De auteurs bewijzen de Frame-Soundness Theorem: als een formule bewijsbaar is vanuit een verzameling axioma's $\Lambda$ , dan is deze geldig in alle frames waar $\Lambda$ geldig is.

Belangrijkste Bijdragen en Resultaten

Algemene Formalisering: Het artikel presenteert de eerste machine-gecontroleerde formalisering van een algemene veel-gesorteerde hybride polyadische modale logica in Lean. Dit systeem ondersteunt arbitraire signaturen, polyadische operatoren en hybride kenmerken (nominalen, de $@$ -operator en binden $\forall$ ).
Mechanische Soundness: Een volledige, "sorry-vrije" bewijs van het soundness-theorema wordt geleverd. Tijdens dit proces hebben de auteurs fouten geïdentificeerd en gecorrigeerd in de oorspronkelijke presentatie van het bewijssysteem in de bestaande literatuur (specifiek met betrekking tot het Barcan-axioma en de Name@ en Paste regels), en een gecorrigeerde versie geleverd met de noodzakelijke syntactische zijdelingse voorwaarden.
DSL voor Signatuurdefinitie: De auteurs hebben een Domain Specific Language (DSL) ontwikkeld met het hybrid_def keyword. Hiermee kunnen gebruikers veel-gesorteerde signaturen definiëren met behulp van een vertrouwde Backus-Naur Form (BNF)-achtige notatie, die automatisch wordt geëlaborreerd naar de onderliggende Lean-datastructuren (Symbols, Signature, etc.).
Drie Geverifieerde Applicaties: De veelzijdigheid van het framework wordt gedemonstreerd door drie afzonderlijke toepassingen:
- SMC Machine (Programma-analyse): De auteurs hebben de operationele semantiek van de SMC machine (een imperatieve taal) geformaliseerd als een hybride logische signatuur. Zij hebben Hoare-achtige inferentieregels afgeleid en de correctheid geverifieerd van een programma dat variabelen wisselt en conditionele executie met bijwerkingen bevat.
- Beveiligingsprotocollen: Het framework werd gebruikt om BAN-logica en een hybride logica voor beveiligingsprotocollen in te bedden. Zij verifieerden authenticatie-eigenschappen in het Needham-Schroeder Public Key (NSPK) protocol en analyseerden het One-Sided Secrecy (OSS) protocol, waarbij wederzijdse authenticatie en kennis-eigenschappen werden bewezen.
- S5 Modale Logica: De auteurs hebben aangetoond dat het systeem zichzelf kan beperken tot een puur modaal fragment (door hybride kenmerken te verwijderen) om stellingen in het S5 modale systeem te definiëren en te bewijzen, wat het vermogen van het framework aantoont om minder expressieve fragmenten van de basislogica te verwerken.

Betekenis en Claims

Het artikel claimt dat het voorgestelde systeem dient als een algemeen verificatieframework dat in staat is om de specificatie van programmeertalen, hun operationele semantiek en correctheidseigenschappen te verenigen binnen één enkele logische fundering.

Modulariteit en Uitbreidbaarheid: De auteurs benadrukken dat de architectuur modulair is. Gebruikers kunnen aangepaste talen of protocollen definiëren als veel-gesorteerde signaturen en domeinspecifieke axioma's specificeren zonder de kernlogica te wijzigen.
Intrinsieke Veiligheid: Door gebruik te maken van intrinsieke sortering garandeert het framework dat elke geconstrueerde formule een geldige parse is van de gedefinieerde grammatica, wat een klasse van fouten elimineert die veel voorkomt in andere formalisaties.
Onderzoeksinstrument: De representatie van variabelen als concrete namen (in plaats van de Bruijn-indices) is een bewuste keuze om de migratie van pen-en-papier logisch onderzoek naar de formele setting te vergemakkelijken, waardoor de representatieve overhead wordt geminimaliseerd.

Dit werk positioneert zich als een rigoureuze fundering voor toekomstige uitbreidingen, waarbij expliciet wordt opgemerkt dat het bewijs van de Volledigheid (Completeness Theorem) een doel blijft voor toekomstige mechanisatie, en dat de ontwikkeling van gebruiksvriendelijke tactieken een prioriteit is om het systeem toegankelijk te maken voor niet-experts in de implementatiedetails. De code is openbaar beschikbaar ter ondersteuning van reproduceerbaarheid en verdere ontwikkeling in het vakgebied.