Nonstandard Axiomatic Semantics
Dit artikel toont aan dat axiomatische semantiek gebaseerd op Hoare-logica niet-standaard modellen toelaat die vergelijkbaar zijn met die van Skolem, waardoor het faalt om de operationele semantiek uniek te definiëren, en stelt voor het systeem te verrijken met aanvullende bewijslast om deze ambiguïteit op te lossen zonder de standaard trace-modellen te beïnvloeden.
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
In de wereld van de informatica bestaat er een constante spanning tussen hoe we beschrijven wat een programma moet doen en hoe we bewijzen dat het dat ook daadwerkelijk doet. Decennialang hebben onderzoekers vertrouwd op een systeem genaamd Hoare-logica om software te verifiëren. Dit systeem werkt als een reeks logische regels: als een programma in een bepaalde staat begint en we kunnen bewijzen dat het specifieke stappen volgt, dan moet het eindigen in een gewenste staat. Het is een krachtig hulpmiddel om te garanderen dat code vrij is van fouten, vergelijkbaar met hoe een wiskundig bewijs garandeert dat een stelling waar is. Echter, net zoals wiskundigen ooit ontdekten dat hun regels voor het tellen van getallen per ongeluk vreemde, onmogelijke werelden konden beschrijven, hebben informatici ontdekt dat de regels voor het verifiëren van programma's ook onmogelijke manieren kunnen beschrijven waarop code kan draaien. De vraag is of de logica die we gebruiken om onze software te vertrouwen, wel nauwkeurig genoeg is om deze onmogelijke scenario's uit te sluiten.
Een onderzoeker aan de New York University heeft onlangs aangetoond dat de standaardregels voor het verifiëren van programma's inderdaad te los zijn. Zij demonstreerde dat de logica die wordt gebruikt om programma's correct te bewijzen, "niet-standaard" modellen van uitvoering toestaat. In eenvoudige bewoordingen betekent dit dat de regels toestaan dat een programma op manieren draait die binnen de logica wiskundig mogelijk zijn, maar fysiek onmogelijk in de echte wereld. Stel je een programma voor dat eeuwig blijft tellen. De standaardvisie is dat het bij nul begint en naar één, twee, drie, enzovoort gaat, zonder ooit te stoen. De logica staat echter ook een versie van dit programma toe die een oneindige tijd in het verleden heeft gedraaid voordat we het überhaupt begonnen te observeren, of die bestaat in een vreemde, uitgebreide tijdlijn die niet overeenkomt met ons normale begrip van tijd. De onderzoeker bewees dat de huidige logica het verschil niet kan zien tussen het normale, verwachte gedrag van een programma en deze bizarre, niet-standaard gedragingen. Dit is een aanzienlijk probleem, want als de logica het verschil niet kan zien tussen de echte wereld en deze onmogelijke werelden, definieert het niet uniek wat een programma daadwerkelijk doet.
Om te begrijpen waarom dit gebeurt, moet men kijken naar hoe lussen in computerprogramma's worden geverifieerd. Wanneer een programma een blok code herhaalt, zoals een lus die draait zolang een voorwaarde waar is, vereist de logica een "lus-invariant". Dit is een bewering die waar blijft elke keer dat de lus herhaalt. De onderzoeker toonde aan dat je voor veel programma's een lus-invariant kunt verzinnen die waar is voor de standaard, normale uitvoering van de code, maar die ook waar is voor deze vreemde, niet-standaard executies. Overweeg bijvoorbeeld een programma dat omhoog telt. De logica staat een bewijs toe dat werkt voor een telling beginnend bij nul en omhoog gaand, maar het staat ook een bewijs toe dat werkt voor een telling die vanuit negatief oneindig naar beneden heeft geteld, of voor een telling die bestaat in een tijdlijn met extra, onzichtbare stappen die mensen niet kunnen waarnemen. Omdat de logica deze verschillende tijdlijnen als geldig behandelt, slaagt het er niet in om een enkele, unieke betekenis aan het programma te geven. De logica is ambigu, vergelijkbaar met een oude definitie van getallen die "geestgetallen" toeliet die zich als normale getallen gedragen, maar geen deel uitmaken van de standaard telreeks.
Het artikel identificeert deze ambiguïteit niet alleen; het biedt een manier om het te herstellen. De onderzoeker stelt voor om extra vereisten toe te voegen aan het verificatieproces, geïnspireerd door methoden die worden gebruikt om te bewijzen dat een programma uiteindelijk zal stoppen met draaien. Deze nieuwe vereisten fungeren als een filter. Ze eisen dat het bewijs van de correctheid van een programma ook moet aantonen dat de uitvoering van het programma een specifiek, standaard pad door de tijd volgt. Specifiek vereisen de nieuwe regels dat als je de stappen van een lus zou tellen, de telling de standaard progressie van getallen moet volgen die we dagelijks gebruiken, zonder verborgen, oneindige uitbreidingen. Als het gedrag van een programma steunt op die vreemde, niet-standaard tijdlijnen, zullen de nieuwe regels er niet in slagen het correct te bewijzen. Dit dwingt de logica effectief om de onmogelijke werelden te negeren en zich te concentreren op de standaard, echte executies waar we om geven.
Cruciaal is dat de onderzoeker laat zien dat voor elk programma dat normaal gedrag vertoont, deze nieuwe vereisten automatisch worden voldaan. Dit betekent dat voor het overgrote deel van het werk aan softwareverificatie dat mensen vandaag de dag doen, de bestaande bewijzen geldig en ongewijzigd blijven. De nieuwe regels maken het werk om programma's correct te bewijzen niet moeilijker voor standaardgevallen; ze sluiten simpelweg de achterdeur die de onmogelijke gevallen binnenliet. Het resultaat is een preciezere definitie van wat een programma betekent. Door deze extra controles toe te voegen, wordt de logica eindelijk een unieke beschrijving van programmagedrag, wat ervoor zorgt dat wanneer we zeggen dat een programma correct is, we praten over precies één specifieke manier waarop het draait, en niet over een collectie mogelijke realiteiten inclusief sommige die de menselijke kennis van tijd en sequentie tarten.
Dit werk verbindt een diep probleem in de fundamenten van de wiskunde met de praktische taak van het schrijven van veilige software. Net zoals wiskundigen ooit hun definitie van getallen verfijnden om onmogelijke variaties uit te sluiten, verfijnt dit onderzoek de definitie van programmatige uitvoering. Het zorgt ervoor dat de instrumenten die we gebruiken om de veiligheid van kritieke systemen te verifiëren, niet alleen logisch consistent zijn, maar ook geworteld zijn in de enkele, standaard realiteit van hoe computers daadwerkelijk werken. De oplossing is elegant omdat het niet vereist het hele systeem van programmareverificatie te herschrijven; het voegt simpelweg een vangrail toe die de logica op het beoogde pad houdt, waardoor onze vertrouwen in software gebaseerd is op een unieke en goed gedefinieerde waarheid.
Verdrinkt u in papers in uw vakgebied?
Ontvang dagelijkse digests van de nieuwste papers die bij uw onderzoekswoorden passen — met technische samenvattingen, in uw taal.