A Formalization of Abstract Rewriting in Agda

Each language version is independently generated for its own context, not a direct translation.

Stel je voor dat je een enorme, chaotische bibliotheek hebt. In deze bibliotheek zijn boeken (we noemen ze "termen") die je kunt herschrijven. Je kunt een boek openen, een zin vervangen door een andere, en zo een nieuw boek maken. Soms leidt dit tot een eindeloos verhaal dat nooit stopt, en soms kom je op een punt waar je niets meer kunt veranderen: een "normaal vorm" (een boek dat perfect is en niet meer aangepast kan worden).

Dit artikel gaat over een digitale bibliotheekbouwer genaamd Agda. De auteurs, Samuel en Andrew, hebben een heel strakke, wiskundige handleiding geschreven voor Agda over hoe je deze herschrijf-systeem (Abstract Rewriting Systems) precies moet begrijpen en bouwen.

Hier is de uitleg in simpele taal, met een paar creatieve vergelijkingen:

1. Het Probleem: De "Gouden Standaard" is te oud

In de wiskunde bestaan er al oude, klassieke regels over hoe deze herschrijf-systemen werken. Maar deze oude regels gebruiken vaak "magische" logica (klassieke logica). Het is alsof je zegt: "Of dit boek eindigt, of het eindigt niet. We weten het niet, maar we doen alsof we het wel weten."

Voor een computer (en voor Agda) is dit niet goed genoeg. Een computer wil bewijzen dat iets werkt, niet alleen maar aannemen dat het wel zo is. De auteurs wilden dus de oude regels "ontmagischen". Ze wilden bewijzen die echt werken, stap voor stap, zonder magische aannames. Ze hebben de handleiding herschreven zodat elke stap een echt, uitvoerbaar programma is.

2. De Oplossing: Bouwen met Legostenenen

Stel je voor dat je een toren bouwt.

De oude manier: Je zegt: "Als de toren niet instort, is hij goed." (Dit is een klassiek bewijs: je neemt aan dat het niet misgaat).
De nieuwe manier (Agda): Je bouwt de toren steen voor steen. Als je een steen zet, moet je kunnen laten zien waarom die steen blijft zitten. Als je dit doet, heb je niet alleen een bewijs dat de toren staat, maar heb je ook de instructies om de toren daadwerkelijk te bouwen.

In dit artikel hebben de auteurs laten zien dat je de meeste regels over herschrijven kunt bouwen met deze "steen-voor-steen" methode. Ze hebben zelfs nieuwe, betere regels gevonden die nog sterker zijn dan de oude.

3. Belangrijke Concepten (Vertaald naar alledaags)

Terminatie (Eindigen):
Stel je voor dat je een spelletje speelt waarbij je elke beurt een kaart moet leggen die kleiner is dan de vorige. Uiteindelijk moet je op een "1" belanden en stoppen.
- Sterke terminatie: Je bent gegarandeerd dat het spel stopt, ongeacht welke kaarten je kiest.
- Zwakke terminatie: Er is een manier om te spelen die stopt, maar misschien kies jij per ongeluk een weg die nooit stopt.
  De auteurs hebben ontdekt dat je vaak een extra "slimme truc" (een beslissingsregel) nodig hebt om van "sterk" naar "zwak" te gaan. Voor simpele systemen (zoals gewone programmeertalen) werkt dit makkelijk. Voor heel gekke, abstracte systemen werkt het misschien niet.
Confluëntie (De kruispunten):
Stel je voor dat je twee verschillende routes neemt om naar huis te gaan.
- Confluëntie: Het maakt niet uit welke route je kiest, je komt uiteindelijk op exact hetzelfde punt uit.
- De auteurs hebben bewezen dat als je weet dat je spel altijd stopt (terminatie) en dat je lokale keuzes geen problemen opleveren, je gegarandeerd op hetzelfde eindpunt uitkomt. Ze hebben dit bewijs zelfs verbeterd: je hebt minder strenge eisen nodig dan vroeger dachten.
De "Magische" Logica:
Soms zeggen oude wiskundigen: "Als er een oplossing is, dan is er een oplossing." Maar in de computerwereld willen we de oplossing zien. De auteurs hebben gekeken waar ze die "magische" aannames konden vervangen door echte, berekenbare stappen. Ze hebben ontdekt dat voor de meeste praktische toepassingen (zoals het controleren van code of wiskundige formules) je die magie helemaal niet nodig hebt.

4. Waarom is dit belangrijk? (De "Waarom"-vraag)

Stel je voor dat je een nieuwe programmeertaal wilt bouwen. Je wilt zeker weten dat je programma's niet oneindig blijven draaien (geen "eindeloze lussen") en dat je altijd hetzelfde resultaat krijgt, ongeacht hoe je de code schrijft.

Met deze nieuwe handleiding (de Agda-bibliotheek) kunnen programmeurs en onderzoekers:

Automatisch bewijzen dat hun taal veilig is.
Code genereren die deze bewijzen uitvoert. Het bewijs is niet alleen een "ja/nee"-antwoord, maar een echt programma dat de oplossing berekent.
Betere software bouwen, omdat ze weten dat hun systemen niet vastlopen in logische valkuilen.

5. Het Grote Doel: Een "Bootstrapping"

De auteurs noemen hun werk "bootstrapping". Dat is als het opstarten van een computer: je hebt een klein programmaatje nodig om het grote besturingssysteem te laden.
Ze hebben dit kleine, krachtige pakketje (de basisregels voor herschrijven) gemaakt. Nu kunnen andere onderzoekers dit pakketje gebruiken om enorme, complexe bibliotheken te bouwen voor programmeertalen, zonder dat ze elke keer de basisregels opnieuw hoeven uitvinden.

Kortom:
De auteurs hebben de "regels van het spel" voor computerherschrijving herschreven. Ze hebben de oude, wazige magische regels vervangen door heldere, stap-voor-stap instructies die een computer echt kan uitvoeren. Hierdoor kunnen we in de toekomst complexere en veiligere software bouwen, wetende dat de onderliggende logica waterdicht is. Ze hebben de fundamenten gelegd voor een nieuwe generatie van bewezen correcte software.

Each language version is independently generated for its own context, not a direct translation.

Hier is een gedetailleerde technische samenvatting van het artikel "A Formalization of Abstract Rewriting in Agda" van Samuel Arkle en Andrew Polonsky, geschreven in het Nederlands.

Probleemstelling

Abstracte Herschrijfsystemen (Abstract Rewriting Systems - ARS) vormen de fundamentele theorie voor het analyseren van convergentie (confluence) en terminatie in programmeertalen en term-herschrijfsystemen (TRS). Hoewel veel resultaten in de bestaande literatuur (zoals in het standaardwerk Terese van Bezem, Klop en De Vrijer) constructief zijn, maken de standaardbewijzen vaak gebruik van klassieke logica (bijvoorbeeld het principe van de uitgesloten derde of bewijzen door contradictie).

In de context van bewijsassistenten zoals Agda, die gebaseerd zijn op de Curry-Howard-isomorfisme, zijn bewijzen ook uitvoerbare programma's. Het gebruik van klassieke logica maakt bewijzen echter niet-constructief, wat betekent dat ze geen effectieve algoritmen genereren. Dit beperkt de bruikbaarheid van deze theorie voor het bouwen van geautomatiseerde tools, het genereren van normalisatie-algoritmen, en het modelleren van kwotienten in puur type-theoretische omgevingen zonder extra axioma's. De auteurs stellen de vraag: Hoe kan de theorie van ARS volledig constructief worden geformaliseerd, waarbij klassieke logica wordt geëlimineerd of expliciet gemarkeerd, en waarbij de bewijzen direct bruikbare berekeningen opleveren?

Methodologie

De auteurs hebben een bibliotheek voor ARS geïmplementeerd in Agda, een functionele programmeertaal en interactieve bewijsassistent die gebaseerd is op Martin-Löf intuïtionistische type-theorie.

De kernprincipes van hun aanpak zijn:

Constructiviteit: Alle bewijzen moeten constructief zijn. Er wordt geen gebruik gemaakt van axioma's zoals functie-extensionaliteit, univalentie, of het principe van de uitgesloten derde (Excluded Middle), tenzij expliciet als hypothese geformuleerd.
Programma's als Bewijzen: Bewijzen worden geschreven als recursieve functies die patronen matchen. Een bewijs dat een systeem "Church-Rosser" is, genereert automatisch een functie die een gemeenschappelijke reductie berekent voor twee convertible termen.
Decidabiliteit: Waar klassieke logica normaal gesproken wordt gebruikt om de bestaan van een object aan te tonen, eisen de auteurs expliciete decidabiliteitshypothese (bijv. $Rxy \lor \neg Rxy$ ) om constructieve bewijzen mogelijk te maken.
Taxonomie van Concepten: Ze hebben een uitgebreide hiërarchie van eigenschappen voor terminatie en confluence opgezet en de logische relaties tussen deze eigenschappen onderzocht, inclusief nieuwe, verfijnde definities.

Belangrijkste Bijdragen

1. Constructieve Formalisering van ARS

De auteurs hebben de basisresultaten uit Terese [8] volledig geformaliseerd in Agda. Dit omvat definities van:

Normalisatie: Sterk genormaliseerd (SN), zwak genormaliseerd (WN), en normalisatie-eigenschappen (NP, UN).
Confluence: Church-Rosser (CR), zwak Church-Rosser (WCR), en subcommutativiteit.
Relaties: Reflexieve, transitieve en equivalente sluitingen.

2. Verbetering van Standaardresultaten (Generalisaties)

Door de constructieve beperkingen te omzeilen, hebben ze de standaardcriteria voor terminatie en confluence verfijnd:

Veralgemeende Newman's Lemma: Het klassieke lemma stelt dat $SN \land WCR \implies CR$ . De auteurs bewijzen een generalisatie: $SM \land WCR \implies CR$ , waarbij $SM$ (sterk minimaliserend) een zwakkere voorwaarde is dan $SN$ . Dit is significant omdat $SM$ geldt in systemen waar $SN$ faalt (bijv. systemen met oneindige reducties die toch een "minimale" structuur hebben).
Vervanging van 'Inc': De eigenschap "Inc" (bestaan van een grootte-functie naar natuurlijke getallen) uit Terese is vervangen door de constructief zwakkere eigenschap RP (Recurrence Property) of RP-. Dit maakt de theorie toepasbaar op een breder scala aan systemen zonder rekenkundige beperkingen.

3. Analyse van Well-Foundedness (Goed-gegrondeheid)

Een groot deel van het artikel (Sectie 5) is gewijd aan de subtiele verschillen tussen verschillende definities van goed-gegronde relaties in een constructieve context. Klassiek zijn deze equivalent, constructief niet. De auteurs onderscheiden:

Accessibly Well-Founded (WFacc): Inductief gedefinieerd (gebaseerd op toegankelijkheid).
Minimality-wise Well-Founded (WFmin): Elk niet-leeg deel heeft een minimaal element.
Sequentially Well-Founded (WFseq): Geen oneindige dalende rijen.

Ze tonen aan dat de implicatie van $WFmin$ naar $WFacc$ klassiek geldt, maar constructief de uitgesloten derde vereist. Ze identificeren precies welke klassieke principes nodig zijn om tussen deze definities te schakelen (zie Figuur 2 en 3 in het artikel). Voor eindig vertakkende systemen (finitely branching) en decibele relaties, blijken veel van deze implicaties echter wel constructief te gelden.

4. Ontologie van Eigenschappen

De auteurs hebben een hiërarchie opgesteld van terminatie- en confluence-eigenschappen. Ze tonen aan dat combinaties zoals $WN \land UN_{\to} \implies CR$ constructief gelden, terwijl $SN \land UN_{\to} \implies CR$ klassieke logica vereist (tenzij $WCR$ ook geldt). Ze bieden tegenvoorbeelden (Counterexamples) om te laten zien waar klassieke logica onmisbaar is.

Resultaten

Effectiviteit: De meeste ARS-resultaten zijn bewezen als effectieve algoritmen. Bijvoorbeeld, een bewijs van Strong Normalization (SN) in Agda fungeert als een algoritme dat voor elke term een eindige reductie naar een normaalvorm vindt.
Decidabiliteit: Voor eindig vertakkende systemen (zoals standaard TRS en lambda-calculus) zijn de benodigde decidabiliteitshypothese ( $Rxy \lor \neg Rxy$ ) van nature aanwezig, waardoor de theorie volledig toepasbaar is.
Lambda Calculus Applicatie: De bibliotheek is succesvol toegepast op de ongetypeerde lambda-calculus. Hierdoor kunnen resultaten zoals de beslisbaarheid van normalisatie en de consistentie van de theorie (distincte normalen zijn niet convertible) direct worden afgeleid uit de algemene ARS-theorie, zonder ze opnieuw te hoeven bewijzen.
Nieuwe inzichten: De relatie tussen $SM$ (sterk minimaliserend) en $SN$ is verduidelijkt, wat leidt tot een generalisatie van Newman's Lemma die geldig is in systemen waar klassieke terminatie faalt.

Significantie

Deze werken is van groot belang voor de theorie van programmeertalen en formele methoden:

Infrastructuur voor PL-theorie: Het biedt een "bootstrapped" basis voor een groter project aan de Appalachian State University om programmeertaaltheorie (PL) volledig te formaliseren.
Kwaliteit van Bewijzen: Het demonstreert dat bewijzen niet alleen correctheid verifiëren, maar ook uitvoerbare code genereren. Dit is essentieel voor het bouwen van tools die normalisatie of conversie daadwerkelijk kunnen uitvoeren.
Klassiek vs. Constructief: Het artikel biedt een helder overzicht van waar klassieke logica in de herschrijvingsliteratuur wordt gebruikt en hoe deze kan worden vervangen door constructieve alternatieven of expliciete decidabiliteitsvoorwaarden.
Toekomstige Toepassingen: De formalisatie maakt het mogelijk om resultaten van externe terminatie-provers (zoals die van de Annual International Termination Competition) te importeren en te gebruiken in Agda, wat de integratie van geautomatiseerde tools en interactieve bewijzen bevordert.

Kortom, het artikel transformeert een klassieke, vaak niet-constructieve wiskundige theorie in een robuuste, computable bibliotheek die direct bruikbaar is voor de ontwikkeling van geavanceerde programmeertaaltheorie en verificatietools.