Open-Source LLM-Driven Formal Verification: A Multi-Agent Pipeline for RTL Repair

Stel je voor dat je een enorme, ingewikkelde kasteel bouwt van digitale Lego-steentjes. Dit is wat ingenieurs doen wanneer ze computerchips ontwerpen: ze schrijven code die RTL (Register Transfer Level) wordt genoemd, die de kleine transistors vertelt hoe ze zich moeten gedragen. Maar hier is de crux: als zelfs maar één steentje op de verkeerde plek wordt geplaatst, kan het hele kasteel instorten zodra de stroom wordt ingeschakeld. Het controleren op dergelijke fouten is het moeilijkste deel van de klus, en neemt vaak meer dan de helft van de tijd in beslag. Traditioneel hebben ingenieurs twee belangrijke manieren gebruikt om hun werk te controleren. De eerste is als een "proefrit", waarbij ze de chip door een paar specifieke scenario's leiden om te zien of hij kapot gaat. De tweede is "formele verificatie", wat een soort super-wiskundig bewijs is dat garandeert dat het kasteel onder elke mogbare conditie blijft staan, en niet alleen onder de condities die ze hebben getest. Echter, deze super-bewijs methode vereist meestal dure, afgeschermde software die alleen grote bedrijven kunnen betalen.

Maak kennis met de nieuwkomer op het gebied: Large Language Models (LLM's). Je kent ze misschien als de AI-chatbots die verhalen of code kunnen schrijven. Onlangs begonnen mensen zich af te vragen: "Kan een AI de architect zijn die onze kapotte digitale kastelen repareert?" De grote vraag is of een AI niet alleen een fout kan opsporen, maar deze ook kan herstellen op een manier die wiskundig bewezen perfect is, zonder dat er een miljoen dollar aan softwarelicenties nodig is. Dit artikel duikt in die vraag en probeert een brug te slaan tussen de creativiteit van AI en de strikte, onverbiddelijke logica van de formele wiskunde, met behulp van uitsluitend gratis, open-source tools.

De AI-detective en de Open-Source Gereedschapskist

In dit onderzoek heeft een onderzoeker genaamd Ha Trung Tran een slim team van AI-agenten gebouwd om te fungeren als een reparatieteam voor defecte chipontwerpen. Denk aan een hoogtechnologische detectiveploeg die in een lus werkt. In plaats van één AI die alles tegelijk probeert te doen, is het team verdeeld: één agent leest de blauwdrukken, een ander schrijft de regels voor wat de chip zou moeten doen, een derde controleert het werk, en een vierde repareert daadwerkelijk de code.

Het geheime ingrediënt hier is hoe ze controleren op fouten. De meeste AI-reparatietools draaien gewoon een paar proefritten (simulaties) om te zien of de chip werkt. Maar dit team gebruikt een "formele backend"—een gratis, open-source wiskundige motor bestaande uit tools genaamd Yosys, SymbiYosys en Z3. Deze motor gokt niet; hij probeert wiskundig te bewijzen dat de chip correct is. Als de chip faalt, zegt de engine niet alleen "het is kapot". Het overhandigt de AI een specifiek "tegenvoorbeeld" (counterexample), wat een soort videoreplay is die precies laat zien hoe het kasteel is ingestort. De AI bekijkt vervolgens deze video, ontdekt wat er misging, en probeert het te repareren. Ze blijven dit herhalen—controleren, de crash vinden, repareren, opnieuw controleren—totdat de wiskunde bewijst dat de chip perfect is of tot ze geen pogingen meer over hebben.

Het Goede Nieuws: Het Werkt (Soms)

De onderzoekers testten dit systeem op zes verschillende soorten digitale ontwerpen, variërend van een simpel rekenonderdeel (een ALU) tot complexere verkeerscontrollers en geheugenunits. De resultaten waren een mix van triomf en duidelijke beperkingen.

De ster van de show was de ALU (Arithmetic Logic Unit), die lijkt op het rekenbrein van een chip. De onderzoekers hebben het ontwerp opzettelijk beschadigd door een "AND"-operatie te vervangen door een "OR"-operatie. Het AI-team merkte de fout onmiddellijk op. In slechts twee rondes van controleren en repareren hebben ze de code hersteld. Belangrijker nog: de open-source wiskundige engine bewees met 100% zekerheid dat de reparatie correct was voor elk mogelijk getal dat de chip ooit zou verwerken. Dit gebeurde in alle vijf de testruns, met een gemiddelde tijd van slechts 16,5 seconden. Het bewees dat het idee werkt: een AI, geleid door open-source wiskundige tools, kan een echte bug vinden en herstellen met een wiskundige garantie.

Het Slechte Nieuws: Waar de AI Vastliep

Echter, het verhaal is niet alleen maar een overwinning. Wanneer de onderzoekers hetzelfde proces probeerden op de andere vijf ontwerpen, liep het AI-team tegen een muur aan. Ze konden deze niet betrouwbaar repareren. Het paper analyseert zorgvuldig waarom ze faalden en identificeert vier verschillende "foutmodi" die als vallen voor de AI fungeren:

1. De "Te Diepe" Val (Bounded-Cover Vacuity): In één geval (een teller) zei de wiskundige engine "FAIL" terwijl de reparatie eigenlijk correct was. Waarom? Omdat het ontwerp 256 cycli nodig had om een specifieke staat te bereiken, maar de tool keek slechts 256 cycli diep. Het was also려 een auto te testen of hij een reis door het land kan maken door hem slechts één mijl te laten rijden; de tool kon de bestemming niet zien, dus gaf hij op. Het paper merkt op dat dit een limiet van de tool is, niet van de AI.
2. De "Verwarrende Instructies" Val (Specification Ambiguity): Bij een ander ontwerp (een arbiter) probeerde de AI de geschreven regels te volgen, maar de regels vroegen om iets onmogelijks (zoals een verkeerslicht dat verandert zonder een klok). De AI volgde de onmogelijke instructies getrouw, wat leidde tot een doodlopende weg.
3. De "Tijdreis" Val (Temporal Logic Bugs): In twee gevallen (een UART-zender en een FIFO-geheugen) gingen de bugs over gebeurtenissen die over meerdere tijdstappen plaatsvonden. De AI was goed in het repareren van logica in één stap (zoals de rekenmachine), maar had moeite met het redeneren over sequenties van gebeurtenissen die over een bepaalde tijd plaatsvonden.
4. De "Te Veel Regels" Val (Multi-Property Pressure): In het laatste geval (een AXI Lite slave) waren er zoveel regels waar de chip zich tegelijkertijd aan moest houden, dat het repareren van één regel een andere regel verbrak. De AI kwam vast te zitten in een loop, niet in staat om een oplossing te vinden die iedereen tevreden stelde.

Een Verborgen Fout in de Gereedschapskist

Er was ook een verrassende ontdekking over de open-source tools zelf. De onderzoekers ontdekten dat de Yosys-tool, die helpt bij het verwerken van de code, een verborgen eigenaardigheid heeft. Als je probeert de veiligheidscontroles (assertions) aan het ontwerp te koppelen met een specifieke methode genaamd "bind", negeert de tool deze stilletjes. Het is alsof je een beveiligingscamera in een kamer plaatst, maar de camera niet hebt aangesloten; het systeem denkt dat alles in orde is omdat het de camera nooit ziet. De onderzoekers moesten hun methode veranderen naar het direct "injecteren" van de controles in de code om er zeker van te zijn dat de wiskundige engine ze daadwerkelijk zag. Dit is een nuttige tip voor iedereen die deze gratis tools gebruikt.

De Kern van het Verhaal

Dit paper is een "haalbaarheidsstudie", wat een chique manier is om te zeggen: "We hebben het geprobeerd, en dit is precies waar het werkt en waar het breekt." De belangrijkste bevinding is dat het mogelijk is om een AI te gebruiken om chipontwerpen te repareren met een wiskundig bewijs van correctheid, maar alleen als je open-source tools gebruikt en als het probleem niet te complex is.

De auteur is eerlijk over de beperkingen: het systeem is geweldig in het repareren van eenvoudige, directe logische fouten (zoals de rekenmachine), maar het worstelt momenteel met complexe timing-problemen, diepe geheugenstaten of ontwerpen met conflicterende regels. De auteur beweert niet het probleem van chipreparatie te hebben opgelost; in plaats daarvan is er een duidelijke kaart getekend die de "veilige zone" laat zien waar de AI werkt en de "gevarenzone" waar de AI verdwaalt. Door uitsluitend gratis tools te gebruiken, hopen ze de drempel voor dit soort onderzoek te verlagen, door te bewijzen dat je geen miljoenenbudget nodig hebt om de toekomst van betrouwbaar hardwareontwerp vorm te geven.