💻 computer science

Untrusted Authors, Trusted Answers: A Calculus of Fidelity-Graded Translations

Dit artikel presenteert een in Lean 4 gemachinaliseerde calculus en een duaal-vlak systeem ("hurdy-gurdy") dat niet-vertrouwde LLM's in staat stelt om zelf-certificerende, op getrouwheid gegradeerde vertalingen tussen programmeertalen te genereren, waarbij wordt gewaarborgd dat een continu evoluerende, door mensen geverifieerde vertrouwensgraaf convergeert naar beslisbare programma-vragen met steeds toenemende zekerheid.

Oorspronkelijke auteurs: Christoph Kirsch

Gepubliceerd 2026-07-20

📖 7 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Christoph Kirsch

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

Het Dilemma van de Detective: Wanneer je de Boodschapper niet kunt vertrouwen

Stel je voor dat je een mysterie probeert op te lossen over een complexe machine, zoals een automotor of het gedrag van een videogame-personage. Je hebt een vraag: "Zal deze auto crashen als ik het gaspedaal indruk bij 50 mph?" Om dit te beantwoorden, kun je niet simpelweg naar de auto kijken; je moet de rommelige, reële mechanica van de auto vertalen naar een taal die een superintelligente computeroplosser begrijpt, zoals een wiskundige vergelijking. Maar hier komt de adder onder het gras: de persoon die de auto naar wiskunde vertaalt, kan een fout maken. Misschien zijn ze een tandwiel vergeten, of hebben ze verkeerd begrepen hoe de remmen werken. Als de vertaler fout zit, geeft de wiskundige oplosser je een perfect antwoord op de verkeerde vraag.

In de wereld van de informatica is dit het probleem van "vertaling". We moeten een programma vaak van de ene taal (zoals C of Python) naar een andere taal (zoals een logische puzzel voor een oplosser) verplaatsen om te controleren of het veilig is. Traditioneel probeerden wetenschappers dit op te lossen door te bewijzen dat de vertaler één en voor altijd perfect was, zoals het certificeren van een brug voordat er iemand overheen rijdt. Maar dat is ongelooflijk moeilijk, vooral wanneer de vertalers complex zijn of zelfs door kunstmatige intelligentie zijn geschreven. Dit artikel stelt een andere vraag: Wat als we stoppen met proberen te bewijzen dat de vertaler perfect is, en in plaats daarvan een systeem bouwen dat de fouten van de vertaler oppikt terwijl deze werkt? Het is het verschil tussen het vertrouwen op een enkele gids om je door een bos te leiden en het hebben van een team van gidsen die elkaars kaarten controleren, met een regel dat als ze het oneens zijn, je stopt en uitzoekt wie er fout zit.

De "Hurdy-Gurdy" Machine: Een Fabriek voor Betrouwbare Antwoorden

Dit artikel introduceert een systeem genaamd hurdy-gurdy (genoemd naar een muziekinstrument dat melodieën produceert, maar hier produceert het antwoorden). De auteurs, onder leiding van Christoph Kirsch, stellen een nieuwe manier voor om met computerprogramma's om te gaan: behandel ze als een spelletje "telefoontje" waarbij elke stap wordt gecontroleerd en elk antwoord wordt geleverd met een bonnetje.

Het kernidee is simpel maar krachtig: Vertrouw de vertaler niet; vertrouw het proces.

Stel je voor dat je een vraag hebt over een programma geschreven in C. In plaats van het naar slechts één vertaler te sturen, stuurt het systeem het via twee verschillende paden.

De Vertaling: Het programma wordt vertaald naar een eenvoudigere logische taal (zoals het veranderen van een roman in een wiskundige vergelijking).
De Dubbelcheck: Het systeem voert het originele programma en de vertaalde versie zij aan zij uit. Het controleert of ze zich op dezelfde manier gedragen. Als dat zo is, geweldig! Als dat niet zo is, wijst het systeem exact aan bij welke stap ze uiteenliepen, zoals een scheidsrechter die op het exacte moment van een overtreding op zijn fluitje blaast.
De "Getuige"-truc: Als de oplosser zegt: "Ja, een crash is mogelijk," neemt het systeem niet zomaar het woord van de oplosser aan. Het neemt het "bewijs" (de specifieke omstandigheden die de crash veroorzaken) en speelt deze achterstevoren door de vertaling af. Het voert die omstandigheden terug in het originele programma. Als het originele programma daadwerkelijk crasht, dan is het antwoord 100% echt. Het systeem heeft de plaats van het misdrijf "nagespeeld".

De Twee Vlakken: Bouwen en Gebruiken

Het systeem heeft twee verschillende modi, zoals een fabrieksvloer en een showroom:

Het Gebruiksvlak (De Showroom): Dit is waar de antwoorden worden gegenereerd. Hier stelt een AI (of een mens) vragen. Het systeem gokt niet alleen; het kiest een route, controleert de vertaling, en als het antwoord "Ja, het is mogelijk" is, voert het de replay uit om het te bewijzen. Als het antwoord "Nee, het is onmogelijk" is, vertrouwt het systeem op een stapel controles: meerdere vertalers, meerdere oplossers en zelfs wiskundig geverifieerde certificaten om zeker te zijn.
Het Evolutieplan (De Fabriek): Dit is waar het systeem groeit. Als het systeem een vraag niet kan beantwoorden, geeft het niet zomaar op; het schrijft op waarom het faalde (bijv. "We hebben geen vertaler voor dit specifieke type lus"). Het gebruikt vervolgens een AI om een nieuwe vertaler te bouwen om dat gat te vullen. Eenmaal gebouwd, wordt de nieuwe vertaler getest tegen de oude vertalers. Als het slaagt, wordt het toegevoegd aan het register. Als het faalt, wordt het gecorrigeerd. Deze lus loopt oneindig door, waardoor het systeem slimmer en betrouwbaarder wordt over de tijd, maar cruciaal is dat het groeiproces zelf geen vragen beantwoordt. Het bouwt alleen de instrumenten om vragen te beantwoorden.

De "Onbetrouwbare Auteurs"-Twist

Het meest verrassende deel van het artikel is dat de vertalers zelf zijn gebouwd door onbetrouwbare AI-agenten. De auteurs hebben de vertalers niet handmatig gecodeerd; ze hebben AI-modellen gevraagd om ze te schrijven op basis van een beschrijving van één pagina. Normaal gesproken zou dit een ramp zijn. Maar omdat het systeem elke stap controleert, werden de fouten van de AI onmiddellijk opgemerkt.

In één test miste een AI-vertaler bijvoorbeeld een specifieke instructie, waardoor het anders reageerde dan het originele programma. De "square check" van het systeem (de zij-aan-zij vergelijking) merkte de fout direct op en wees exact de regel en de exacte variabele aan die fout was. Het systeem heeft de vertaler vervolgens hersteld. Het artikel laat zien dat zelfs met AI-auteurs die fouten kunnen maken, de architectuur van het systeem de uiteindelijke antwoorden betrouwbaar maakt.

Wat het Systeem Vond (en Niet Vond)

De auteurs hebben dit systeem getest op een snapshot van hun werk van juli 2026. Hier is wat ze hebben gemeten:

Dekking: Ze hebben programma's succesvol vertaald uit 13 verschillende talen (inclusclusief C, Python en zelfs chemische reactienetwerken) naar logische oplossers. Voor de RISC-V processor-taal konden ze 96 van de 96 specifieke instructietypes vertalen, wat betekent dat het systeem elke instructie in die set kon afhandelen zonder de controle te verliezen.
Overeenstemming: Wanneer ze dezelfde vraag via twee verschillende vertaalpaden stuurden (één gebaseerd op een handboek, één op een formeel model), kwamen de antwoorden in de testgevallen 100% overeen.
Gevonden Defecten: Het systeem heeft 24 specifieke defecten in zijn eigen vertalers en tools gevonden. Sommige waren eenvoudige typefouten, andere waren logische fouten waarbij de AI een computerinstructie verkeerd begreep. Cruciaal is dat het systeem deze fouten vond zonder dat een mens naar de code keek.
De "Blinde Vlek": Het systeem heeft ook een limiet gevonden. Als twee verschillende vertalers dezelfde fout maken (omdat ze beide eenzelfde regel verkeerd begrijpen), kan het systeem dit niet detecteren. Dit wordt een "common-mode failure" genoemd. Het artikel geeft toe dat dit een risico is, maar het systeem is ontworpen om dit risico te minimaliseren door diverse bronnen voor vertalingen te gebruiken.
LLM-spelers: Ze testten of een AI het systeem kon gebruiken om vragen te beantwoorden. In één experiment beantwoordde een AI zonder hulpmiddelen 7 van de 8 vragen correct, maar gokte hij op de moeilijke vraag. De AI met het systeem beantwoordde 8 van de 8 vragen correct, en elk antwoord werd geleverd met een door machines gecontroleerd bewijs.

De Kernboodschap

Dit artikel beweert niet dat het alle problemen met computerveiligheid heeft opgelost. Het zegt niet dat AI-vertalers nu perfect zijn. In plaats daarvan bewijst het dat je een betrouwbaar systeem kunt bouwen uit onbetrouwbare onderdelen.

Door elke vertaling te behandelt als een potentiële fout en een "ratel" te bouwen die alleen toestaat dat verbeteringen blijven staan, creëert het systeem een ladder van vertrouwen. Als de vraag is "Kan dit gebeuren?", kan het systeem de gebeurtenis nagespelen om het te bewijzen. Als het antwoord "Nee, dit kan niet gebeuren" is, gebruikt het systeem een keten van onafhankelijke controles en wiskundig geverifieerde certificaten om zeker te zijn.

De auteurs concluderen dat deze aanpak — het gebruik van een grafiek van routes, het controleren van elke stap en het nagespelen van het bewijs — een levensvatbare manier is om met de complexiteit van moderne software om te gaan, zelfs wanneer de mensen (of AI's) die de instrumenten bouwen feilbaar zijn. Het is een verschuiving van "vertrouwen op de auteur" naar "vertrouwen op de architectuur".

Technisch overzicht: Onbetrouwbare auteurs, vertrouwde antwoorden

Probleemstelling

Het artikel behandelt de fundamentele uitdaging van het beantwoorden van vragen over programma's (bijv. bereikbaarheid, geldigheid van asserties) wanneer de tools die worden gebruikt om die programma's te vertalen en te analyseren onbetrouwbaar zijn. Traditionele benaderingen vertrouwen ofwel op het eenmalig bewijzen van de correctheid van één vertaler (bijv. CompCert), ofwel op het valideren van elke uitvoering van een enkele vertaler. Deze methoden gaan echter uit van een enkele "rand" van vertaling. Het artikel betoogt dat in een complexe ecosystem met meerdere brontalen, diverse redeneerdoelen en potentieel onbetrouwbare auteurs (inclusief LLM's), het vertalingsproces een graaf vormt van vele talen en routes. In deze graaf is elke vertaling een potentieel punt van falen. De kern van het probleem is hoe men deze heterogene, onafhankelijk gebouwde en potentieel onbetrouwbare vertalingen kan samenstellen tot een systeem dat vertrouwde antwoorden biedt zonder dat universele bewijsvoering voor elk component vereist is.

Methodologie: De calculus van fideliteit-gegradeerde vertalingen

De auteurs stellen een formele calculus en een platformimplementatie genaamd hurdy-gurdy voor. De methodologie is gebouwd op twee afzonderlijke "vlakken" die samenkomen in een gedeeld register:

1. Het Gebruiksvlak (Antwoorden op vragen)

Dit vlak beschouwt vertaling als een graaf waarbij knopen talen zijn en randen vertaalparen.

Het Paar en het Vierkant: De fundamentele eenheid is een paar $(A, B)$ $(A, B)$ bestaande uit een vertaler $T$ $T$ , een target-naar-bron terugvoer $\Lambda$ $Λ$ , en gedeelde interpreters. Een paar wordt gevalideerd via een directioneel commutatorvierkant:
- Exactheid: Het gedrag van de bron is gelijk aan het gedrag van de target dat teruggevoerd is (een bisimulatie op behouden observables).
- Overbenadering: Het gedrag van de bron wordt gesimuleerd door het gedrag van de target (wat spierige gedragingen toestaat maar de bron-gedragingen behoudt).
- Beslisbaarheid: Voor elk specifief programma wordt het vierkant gecontroleerd door beide zijden uit te voeren en geprojecteerde traces te vergelijken. Als ze divergeren, wordt de fout gelokaliseerd naar een specifieke stap en observable.
Compositie en Contracten: Routes worden samengesteld als paden door de graaf. Het contract van een route is het componentgewijze snijvlak van de contracten van de stappen, gedefinieerd door vier assen:
- Zekerheidsklasse: Een hiërarchie van geen tot replay, per-run, en universeel.
- Richting: Exact of overbenadering.
- Behouden Observables: De intersectie van observables die door elke stap worden behouden (verlies cumuleert).
- Kosten: Gemeten als executietijd.
Vertrouismechanismen:
- Per-Run Herstel: Zelfs een "vertrouwde" stap kan dynamisch gevalideerd worden als de square-oracle slaagt voor de specifiebre run.
- Tak-corroboratie: Als twee onafhankelijk afgeleide routes (diverse prefixes) het eens zijn over een oordeel, is het bewijs sterker dan de individuele graad van één route.
- Existentiële/Universele Asymmetrie:
  - Existentiële Antwoorden (Bereikbaar): Zelf-certificerend. Het getuige (witness) van de solver wordt teruggevoerd en afgespeeld (replayed) in de bron-interpreter. Als de replay het gedrag vertoont, is het antwoord waar, ongeacht fouten in de vertaler (Vertrouwensbasis: Adequatesse van de Bron-Interpreter).
  - Universele Antwoorden (Onbereikbaar): Niet zelf-certificerend. Deze vertrouwen op de compositie van graden, tak-overeenstemming en formele certificaten (bijv. DRAT-bewijzen gecontroleerd door geverifieerde checkers).

2. Het Evolutieplan (De graaf laten groeien)

Dit vlak beheert de groei van de vertalingsgraaf.

Onbetrouwbare Generatie: Paren worden geïmplementeerd door onafhankelijke LLM-agenten op basis van briefings.
De Ratel (The Ratchet): Het systeem dwingt een additief groeimodel af. Nieuwe bijdragen moeten de dekking uitbreiden zonder eerdere oordelen ongeldig te maken.
Vraag en Registratie: Onbeantwoordbare vragen worden geregistreerd als "vraag" (demand). Aanbevelingen voor nieuwe paren worden gegenereerd op basis van bewijs. Menselijke registratie is de laatste poortwachter; het systeem beantwoordt niet autonoom vragen, maar breidt slechts de capaciteit uit om dat te doen.

Belangrijkste Bijdragen

Een Calculus van Directionele, Fideliteit-gegradeerde Paren: Een formeel kader waar exactheid een speciaal geval is van overbenadering, en compositie wordt gedefinieerd door een "zwakste schakel" snijvlak over zekerheid, richting, verlies en kosten.
De Contract-algebra: Een mechanisme om heterogene bewijslast te componeren. Het artikel formaliseert hoe "per-run" controles en "universele" garanties combineren, en hoe verlies (verworpen observables) zich langs een route ophoopt.
De Existentiële/Universele Asymmetrie: Een architecturaal principe dat onderscheid maakt tussen antwoorden die getuigen (witnesses) dragen (zelf-certificerend via bron-replay) en antwoorden die dat niet doen (vereisen gegradeerd vertrouwen en certificaten).
De Twee-Vlakken Architectuur: Een scheiding tussen het "gebruiksvlak" (antwoorden) en het "evolutieplan" (bouwen), waardoor onbetrouwbare agenten het systeem kunnen bouren terwijl de architectuur vertrouwen waarborgt door middel van kruiscontroles, diversiteit en de ratel.
Mechanisatie: De compositorische kern, inclus van de pasting theorem, lokalisatie en de end-to-end asymmetrie-stellingen, is gemecaniseerd in Lean 4 (ongeveer 1.250 regels) met een schone axiomataudit.

Resultaten en Evaluatie

Het artikel evalueert een "snapshot van juli 2026" van het hurdy-gurdy platform, volledig gebouwd door LLM-agenten zonder menselijke semantische review van de code.

Dekking en Correctheid: Het systeem dekt 13 talen en 15 geregistreerde paren. Het heeft succesvol routes samengesteld voor RISC-V, AArch64, eBPF, Wasm, EVM, Python, en anderen.
- Tak-overeenstemming: Dubbele routes voor RISC-V (handmatig afgeleid versus Sail-afgeleid) en AArch64 kwamen overeen op alle 12 geteste bereikbaarheidsvragen, inclusclus de universele (onbereikbare) oordelen.
- Compliance Benchmark: Een afgeleide benchmark van 78 vragen uit de RISC-V testsuite werd opgelost met 100% overeenstemming tussen routes en 100% correctheid ten opzichte van de grondwaarheid.
Defectdetectie: De architectuur ving 24 defecten op in de door LLM gegenereerde code, waaronder:
- Stille foutieve decodering van instructies (bijv. MUL als ADD) waarbij zowel de interpreter als de vertaler het eens waren (een "blind vlek" die alleen door externe diversiteit werd gevangen).
- Malafide intermediate representations die door de ene solver werden getolereerd maar door andere werden afgewezen.
- Fouten in de eigen instrumentatie van het platform (bijv. een checker-adapter die gebrekkige bewijzen accepteerde).
Escape Rate Experimenten: Semantische mutaties van de RISC-V vertaler werden getest tegen de poorten van het systeem.
- De "square suite" (geconjoinde probes) ving 51/55 mutanten.
- De resterende 4 werden gevangen door de afgeleide benchmark.
- Er werden nul escapes waargenomen in de laatste ronde, hoewel de auteurs opmerken dat dit de mutatiefamilie meet, en niet een zero escape rate voor alle mogheden.
- Common-mode failures (waarbij beide benen van een vierkant identiek fout zijn) werden alleen gevangen door de diverse tak (Sail route) of differentiële analyses, wat de noodzaak van onafhankelijke semantische ankers valideert.
LLM Speler Experiment: Een LLM-agent kreeg de taak om vragen te beantwoorden met behulp van het platform.
- In een tweede iteratie (v2) behaalde de LLM-speler 8/8 correcte antwoorden op moeilijke BTOR2 bereikbaarheidsvragen, terwijl een onbeholpen LLM 7/8 behaalde.
- Cruciaal is dat de antwoorden van de LLM-speler werden vergezeld door machine-gecontroleerde bewijsstukken (bijv. gereplayed witnesses, LRAT-certificaten), terwijl de onbeholpen LLM vertrouwde op "zeg het maar" en betrouwbaarheidsscores.
Prestaties: De overhead van de discipline (elke stap controleren, witnesses afspelen) is klein vergeleken met de solver-call. Vertaling duurt milliseconden; de solver domineert de tijd.

Betekenis en Claims

Het artikel beweert aan te tonen dat vertrouwen in vertaling kan worden gefabriceerd door architectuur in plaats van door de auteur te vertrouwen.

Gedistribueerde Systemen Stance: Het behandelt vertalers als componenten die falen, waarbij falen wordt ingekaderd door gedeverfiederde projecties, beslisbare controles en onafhankelijke routes, in plaats van het te voorkomen via universele bewijsvoering.
De "Ratel" van Vertrouwen: Het systeem is ontworpen om te evolueren. Dekking en zekerheid groeien monotoon; eerdere oordelen blijven behouden zelfs als de graaf uitbreidt.
Bescheidenomvang: De auteurs zijn expliciet dat het systeem een "dated capability snapshot" is. Het claimt niet de onbeslisbaarheid op te lossen of formele verificatie te vervangen. De "bewezen" laag wordt alleen bewoond door specifieke, begrensde vragen met formele certificaten. Het systeem vertrouwt op empirische discharge van interpreter-adequatesse en structurele diversiteit-aannames.
De Asymmetrie: Het artikel concludeert dat voor existentiële antwoorden, vertrouwen "bijna gratis" is (via replay), terwijl voor universele antwoorden, het systeem bewust zekerheid moet "kopen" door middel van gegradeerde niveaus, takken en certificaten.

Het werk stelt dat een systeem gebouwd op deze principes onbetrouwbare auteurs (mens of AI) kan toestaan om bij te dragen aan een geverifieerde redeneer-infrastructuur, mits de architectuur rigoureuze kruiscontroles en compositorische contracten afdwingt.