💻 computer science

Autoformalizing Memory Specifications with Agents

Dit artikel presenteert een methode voor het automatisch converteren van natuurlijke taal DRAM-specificaties naar een formele representatie genaamd DRAMPyML om end-to-end ontwerpverificatietaken mogelijk te maken, vergezeld van de vrijgave van de DRAMBench-dataset om hardware-autoformalisatiecapaciteiten te evalueren.

Oorspronkelijke auteurs: Jan Ole Ernst, Dmitri Michelangelo Saberi, Derek Christ, Thomas Zimmermann, Rajath Salegame, Suhaas M. Bhat, Stanislav Levental, Thomas Dybdahl Ahle, Matthias Jung

Gepubliceerd 2026-05-04

📖 5 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Jan Ole Ernst, Dmitri Michelangelo Saberi, Derek Christ, Thomas Zimmermann, Rajath Salegame, Suhaas M. Bhat, Stanislav Levental, Thomas Dybdahl Ahle, Matthias Jung

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 probeert een ongelooflijk complex, hoogwaardig spoorwegsysteem (een computerchip) te bouwen. De ingenieurs hebben een enorme, dikke regelboek geschreven in gewoon Engels dat precies beschrijft hoe de trein moet gedragen, wanneer deze moet stoppen en hoe snel deze mag rijden. Dit is de specificatie.

Het probleem is dat de mensen die daadwerkelijk de sporen en signalen bouwen (het verificatieteam) niet zomaar het Engelse regelboek kunnen lezen. Ze hebben een strenge, wiskundige "code" nodig die een computer kan controleren om ervoor te zorgen dat de trein nooit ontspoord. Het vertalen van dat dikke Engelse regelboek naar deze strenge code is momenteel een langzaam, handmatig en foutgevoelig proces. Als ze het verkeerd doen, kan de trein later ontsporen, wat miljoenen kost om te herstellen.

Dit artikel introduceert een nieuwe "AI-vertaler" die specifiek is ontworpen om dit probleem op te lossen voor geheugenchips (het soort RAM dat je telefoon, computer en AI-servers aandrijft).

Hier is een uiteenzetting van hun aanpak met behulp van eenvoudige analogieën:

1. Het Probleem: De "Verloren in Vertaling"-Kloof

Momenteel fungeren mensen als vertalers. Ze lezen het Engelse regelboek (zoals de JEDEC-standaarden voor DDR5- of HBM-geheugen) en schrijven handmatig de strenge code.

Het Probleem: De regelboeken zijn enorm (sommige zijn bijna 500 pagina's lang) en zitten vol subtiele details. Mensen raken moe, en AI-modellen raken vaak in de war door de specifieke vakjargon, wat leidt tot "hallucinaties" waarbij de AI regels verzonnen die niet bestaan.
Het Gevolg: Het verificatieproces neemt meer dan de helft van de tijd in beslag om een chip te bouwen, en fouten kunnen doorheen glippen.

2. De Oplossing: Een Gespecialiseerde "Tussenpersoon"-Taal

In plaats van de AI te vragen om direct van "Engels Regelboek" naar "Strenge Code" te springen (wat hetzelfde is als iemand vragen om een roman direct in een programmeertaal te vertalen zonder woordenboek), hebben de auteurs een tussenpersoon-taal gecreëerd die DRAMPyML heet.

De Analogie: Denk aan DRAMPyML als een universeel bouwplan.
- De AI leest het Engelse regelboek.
- Het tekent een bouwplan in DRAMPyML (dat eruit ziet als een stroomschema van verkeerslichten en treinstations).
- Dit bouwplan wordt vervolgens automatisch omgezet in de uiteindelijke strenge code die nodig is voor testen.
Waarom dit helpt: Het is makkelijker voor de AI om de "stroom" van het verkeer goed te krijgen in een bouwplan dan om direct elke enkele regel van de uiteindelijke code perfect te krijgen. Als het bouwplan goed is, zal de uiteindelijke code ook goed zijn.

3. De "Agent": Een Zelfcorrigerende Stagiair

Het artikel gebruikt niet zomaar een standaard AI-chatbot. Ze hebben een AI-Agent gebouwd die fungeert als een ijverige, zelfcorrigerende stagiair.

Hoe het werkt:
1. Leest: De agent leest het Engelse regelboek.
2. Schrijft: Het schrijft een concept van het bouwplan (DRAMPyML).
3. Test: Het voert zijn eigen tests uit op het bouwplan om te zien of het logisch is (bijvoorbeeld: "Heb ik een file gecreëerd waar geen treinen kunnen bewegen?").
4. Repareert: Als de test faalt, leest de agent het regelboek opnieuw, vindt zijn fout en bewerkt het bouwplan.
5. Herhaalt: Het doorloopt dit proces totdat het bouwplan alle tests bestaat.

Dit wordt een "agente" aanpak genoemd omdat de AI hulpmiddelen heeft om zijn eigen werk te controleren, in plaats van slechts één keer te raden en te hopen op het beste.

4. De "Benchmarks": De Trainingsgym

Om te bewijzen dat hun methode werkt, heeft het team een enorme gym gecreëerd genaamd DRAMBench.

Ze hebben handmatig 13 perfecte "gouden standaard" bouwplannen gebouwd voor verschillende soorten geheugenchips (van oude DDR2 tot de nieuwste HBM3).
Vervolgens lieten ze hun AI-Agent proberen deze bouwplannen na te maken vanuit de Engelse regelboeken.
De Score: Ze maten hoe dicht het bouwplan van de AI bij de "gouden standaard" zat met behulp van een wiskundige score genaamd de Jaccard-index (denk hierbij aan een "gelijkheidspercentage").

5. De Resultaten: Wat Werkte?

De "One-Shot" Mislukking: Toen ze de AI vroegen om het in één enkele poging te doen (zonder zijn werk te controleren), had het moeite, vooral met complexe geheugentypes. Het was alsof je een student vraagt een proefschrift te schrijven zonder dat ze mogen redigeren.
De "Agent" Succes: De zelfcorrigerende agent deed het veel beter. Het kon zijn eigen fouten herstellen.
- Zonder voorbeelden om naar te kijken, slaagde het er toch in om de basis goed te krijgen voor eenvoudigere chips.
- Met voorbeelden (door het een bouwplan voor een oudere chip te tonen) werd het zeer nauwkeurig, waarbij het soms perfecte bouwplannen creëerde voor complexe chips.
De Kosten: Hoe complexer de chip, hoe meer "hersencapaciteit" (tokens) de AI nodig had. Echter, de agent was de extra kosten waard omdat het veel hogere kwaliteit resultaten opleverde dan de one-shot pogingen.

Samenvatting

Het artikel beweert dat door het gebruik van een gespecialiseerde "bouwplan"-taal (DRAMPyML) en een AI die zijn eigen werk kan controleren en repareren (de Agent), ze verwarrende Engelse geheugenchip-regelboeken automatisch kunnen omzetten in accurate, testbare modellen. Dit vermindert de behoefte aan mensen om het saaie vertaalwerk te doen, wat mogelijk het chipontwerp versnelt en fouten eerder opsporst.

Ze hebben hun "gym" (het dataset) vrijgegeven zodat andere onderzoekers hun eigen AI-vertalers kunnen testen tegen dezezelfde geheugenchip-standaarden.

1. Probleemstelling

De Design Verification (DV)-fase van halfgeleiderchipontwerp is een belangrijke knelpunt, waarbij meer dan 50% van de ontwerplevenscyclus wordt verbruikt. De kernuitdaging ligt in het vertalen van ongestructureerde natuurlijke taal specificaties (bijvoorbeeld JEDEC-standaarden voor geheugenchips) naar formele, uitvoerbare modellen die vereist zijn voor verificatie.

Huidige AI-benaderingen richten zich doorgaans op het genereren van geïsoleerde SystemVerilog Assertions (SVAs). Deze aanpak heeft echter aanzienlijke beperkingen:

Onvolledigheid: SVAs controleren specifieke eigenschappen, maar genereren geen complete gedragsmodellen, stimulusgeneratoren of functionele dekkingmetrieken.
Ambiguïteit: Specificaties in natuurlijke taal bevatten vaak ambiguïteiten die leiden tot het genereren van syntactisch ongeldige of protocol-afwijkende asserties door LLM's.
Complexiteit: Moderne geheugenstandaarden (DDR5, HBM3, GDDR7) omvatten ingewikkelde timingbeperkingen, complexe commando-interacties en hiërarchische structuren die moeilijk vast te leggen zijn met eenvoudige prompt-naar-code-generatie.

2. Methodologie

De auteurs stellen een Agentic Autoformalization Framework voor dat natuurlijke taal geheugenspecificaties converteert naar een gestructureerde, uitvoerbare intermediaire representatie genaamd DRAMPyML, in plaats van direct SVAs te genereren.

2.1 De Intermediaire Representatie: DRAMPyML

In plaats van direct naar asserties te springen, richt het systeem zich op DRAMPyML, een Python-gebaseerde modelleringstaal gebaseerd op Timed Petri Nets.

Structuur: Het modelleert geheugentoestellen als een tuple van plaatsen (banken, ranks), overgangen (commando's zoals ACT, RD, WR) en bogen (reguliere, inhibitor-, reset- en getimede bogen).
Voordelen: Deze representatie is uitvoerbaar, wat mogelijk maakt om commandotracés, stimulus en timingcontroles te genereren. Het dient als een uniforme bron waaruit downstream SVAs, testbenchs en dekkingmodellen kunnen worden afgeleid.
Formele Definities: Het artikel definieert DRAM Petri-nets wiskundig en introduceert het concept van Trace Equivalence. Het postuleert (en valideert empirisch) Conjecture 3.4: dat het verifiëren van trace-equivalentie voor kleine configuraties (bijvoorbeeld 1 of 2 banken) met korte tracélengtes ( $k=4$ ) voldoende is om equivalentie voor het volledige, complexe apparaat te bewijzen vanwege symmetrie-eigenschappen.

2.2 De Autoformalization Agent

Het systeem maakt gebruik van een iteratieve Agentic Workflow (Figuur 2 in het artikel) in plaats van een eenmalige generatie-aanpak:

Input: De agent ontvangt JEDEC PDF-specificaties, datasheets van leveranciers en de DRAMPyML-bibliotheek.
Iteratieve Lus: De agent gebruikt tools (MCP-servers, LLM-API's) om:
- Specifieke secties van de specificatie te lezen.
- Python-code te schrijven of te bewerken om het Petri-net-graf op te bouwen.
- Zelf-Valideren: Interne validatietests uitvoeren (controleren op deadlocks, verweesde knopen en het genereren van commandotracés om te kruisverwijzen met de specificatie).
Verfijning: Op basis van validatiefeedback verfijnt de agent het model iteratief totdat structurele consistentie en timingcorrectheid zijn voldaan.
Prompting Strategieën: De studie vergelijkt One-Shot prompting (één prompt met expliciete conventies) versus Agentic (iteratieve interactie met de omgeving en tools).

3. Belangrijkste Bijdragen

DRAMBench: De release van de eerste open-source benchmark voor hardware-autoformalisatie, met ground-truth DRAMPyML-formalisaties voor 13 JEDEC-standaarden (dekkend DDR2-5, LPDDR2-5, GDDR5-7 en HBM2-3).
Agentic Framework: Demonstratie dat een iteratieve agent die gebruikmaakt van tool-versterkte validatie aanzienlijk beter presteert dan eenmalige generatie, met name voor complexe specificaties.
Theoretische en Empirische Validatie:
- Formele definitie van DRAM Petri-nets en trace-equivalentie.
- Empirisch bewijs dat het controleren van korte tracés ( $k \le 4$ ) op minimale configuraties (1-2 banken) voldoende is om semantische bugs in de gegenereerde modellen te detecteren, waardoor het probleem van de explosie van de toestandsruimte wordt omzeild.
Benchmarkresultaten: Een uitgebreide evaluatie van state-of-the-art modellen (Sonnet 4.5, GPT-5.2, DeepSeek-v3p2) die de trade-offs tussen tokenkosten en prestaties toont.

4. Experimentele Resultaten

De auteurs evalueerden modellen op het DRAMBench-dataset met twee metrieken:

Jaccard Index: Meet de overlap van legale commandotracés tussen het gegenereerde model en de ground truth.
Timing Constraint Recall: Meet het fractie van ground-truth timingbeperkingen die correct zijn hersteld.

Belangrijkste Bevindingen:

Agentic vs. One-Shot: De agente aanpak behaalde consequent hogere piekprestaties, vooral voor complexe standaarden (bijvoorbeeld DDR5, HBM3) en wanneer geen voorbeelden werden verstrekt. One-shot generatie had moeite met het onbekende outputformaat zonder sterke priors.
Invloed van Voorbeelden: Het verstrekken van "cherry-picked" voorbeelden (bijvoorbeeld het gebruik van DDR3 om DDR4-generatie te helpen) verbeterde de prestaties aanzienlijk voor beide methoden, waardoor one-shot modellen soms beter presteerden dan agenten op eenvoudigere taken.
Modelprestaties:
- DeepSeek-v3p2 (open-weight) presteerde concurrerend met gesloten bronmodellen (Sonnet 4.5, GPT-5.2), en overtrof deze vaak in de agente setting.
- Sonnet 4.5 behaalde de hoogste structurele perfectie voor standaarden zoals HBM2 en DDR2-4 wanneer voorbeelden werden verstrekt.
Foutpatronen: Analyse van complexe fouten (bijvoorbeeld DDR5) toonde aan dat agenten worstelen met:
- Het selecteren van de juiste primitieven (bijvoorbeeld verkeerde precharge-commando's).
- Het modelleren van geheugenhiërarchie (bijvoorbeeld bankgroepen).
- Het afdwingen van timingbeperkingen op het juiste abstractieniveau (coördinaatmismatches waardoor timingbogen inactief worden).
Token-efficiëntie: Hoewel agenten hogere nauwkeurigheid bereiken, verbruiken ze meer tokens. Voor complexe specificaties is de "token versus prestatie"-curve echter gunstig voor de agent, omdat one-shot modellen onafhankelijk van het tokenaantal niet convergeren naar correcte structuren.

5. Betekenis

Dit werk vertegenwoordigt een paradigma-verschuiving in hardwareverificatie:

Van Asserties naar Modellen: Het gaat verder dan het genereren van geïsoleerde asserties naar het creëren van uitvoerbare, gestructureerde gedragsmodellen. Dit maakt een "shift-left" in verificatie mogelijk, wat leidt tot vroegtijdige detectie van ontwerpfouten en de automatische generatie van diverse collateral (stimulus, dekking, SVAs).
Schaalbaarheid: Door gebruik te maken van de DRAMPyML-intermediaire representatie en trace-equivalentiecontrole, biedt de methode een schaalbaar pad naar het verifiëren van moderne, sterk parallelle geheugentoestellen die eerder te complex waren voor geautomatiseerde formalisatie.
Open Science: De release van DRAMBench biedt een gestandaardiseerde, professionele benchmark die eerder ontbrak in de AI-for-Hardware-literatuur, waardoor de gemeenschap voortgang kan volgen in hardware-autoformalisatie.

Concluderend toont het artikel aan dat agente workflows gecombineerd met gestructureerde intermediaire representaties (Petri Nets) het meest haalbare pad zijn naar het automatiseren van de verificatie van complexe halfgeleiderstandaarden, waarbij de beperkingen van huidige direct-naar-assertie LLM-benaderingen worden overwonnen.