💬 NLP

CktFormalizer: Autoformalization of Natural Language into Circuit Representations

CktFormalizer is een raamwerk dat Lean 4's afhankelijk getypeerde HDL benut om LLM's te sturen bij het genereren van hardwarebeschrijvingen die gegarandeerd syntactisch correct zijn, vrij van synthese-onderbrekende defecten en functioneel geverifieerd via machinegecontroleerde bewijzen, waardoor bijna perfecte backend-realiseerbaarheid wordt bereikt en veilige, geautomatiseerde PPA-optimalisatie mogelijk wordt gemaakt.

Oorspronkelijke auteurs: Jing Xiong, Qi Han, Chenchen Ding, He Xiao, Zunhai Su, Chaofan Tao, Ngai Wong

Gepubliceerd 2026-05-11

📖 5 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Jing Xiong, Qi Han, Chenchen Ding, He Xiao, Zunhai Su, Chaofan Tao, Ngai Wong

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 een zeer getalenteerde maar iets slordige architect vraagt om een bouwtekening voor een huis te maken op basis van een mondelinge beschrijving.

In de traditionele wereld van chipontwerp zou je de architect vragen de instructies te schrijven in Verilog (een taal die wordt gebruikt om computerchips te beschrijven). De architect zou een prachtige beschrijving kunnen schrijven, maar omdat Verilog een beetje lijkt op een losse verzameling regels, zou de architect per ongeluk kunnen zeggen: "Sluit een pijp van 4 inch aan op een pijp van 8 inch," of "Maak een gang die terugloopt in zichzelf."

De computer controleert de grammatica en zegt: "Ziet er goed uit!" Maar wanneer het huis daadwerkelijk wordt gebouwd (de chip wordt gefabriceerd), veroorzaken die fouten dat de pijpen barsten of dat de gang mensen opsluit. Dit zijn dure, stille fouten die pas weken later aan het licht komen.

CKTFORMALIZER is een nieuw raamwerk dat het spel verandert. In plaats van de architect direct in de losse taal van Verilog te laten schrijven, dwingt het hen om te schrijven in een strikt, wiskundige taal genaamd Lean.

Zo werkt het, met een eenvoudige analogie:

1. De Strikte Editor (De Compiler)

Beschouw Lean als een superstrikte editor die precies weet hoe een huis moet worden gebouwd.

De Oude Manier: De architect schrijft "Sluit pijp A aan op pijp B." De editor controleert de maten niet. Later komt het bouwteam erachter dat pijp A te klein is.
De CKTFORMALIZER Manier: De architect probeert te schrijven "Sluit Pijp A (maat 4) aan op Pijp B (maat 8)." De editor slaat direct de deur dicht en zegt: "Fout! Je kunt deze niet aansluiten. Maak het nu goed."
Het Resultaat: De architect (een AI) krijgt direct feedback. Ze kunnen niet doorgaan voordat de maten perfect overeenkomen. Dit vangt "breedte-mismatches" en "lussen" op voordat er ook maar één baksteen is gelegd.

2. Het Veiligheidsnet (Typeveiligheid)

In het oude systeem kun je per ongeluk een deur open laten staan in een kamer, en wordt het huis gebouwd met een tochtige, gebroken kamer. In het Lean-systeem zijn de regels zo strikt dat het fysiek onmogelijk is om een bouwtekening te schrijven met een gebroken kamer.

Als de architect vergeet te beschrijven wat er gebeurt wanneer een schakelaar wordt omgezet, zegt de editor: "Je hebt een geval gemist! Je moet elke mogelijkheid beschrijven."
Dit zorgt ervoor dat het ontwerp "correct door constructie" is. Als het compileert (de controle van de editor doorstaat), is gegarandeerd dat het structureel gezond is.

3. Het Bewijs van Waarheid (Formele Verificatie)

Normaal gesproken bouw je om te controleren of een huisontwerp werkt een klein model en test je dit. Soms werkt het model, maar werkt het echte huis niet.
CKTFORMALIZER gebruikt wiskundige bewijzen. De AI raadt niet zomaar; ze schrijft een wiskundig bewijs dat zegt: "Dit nieuwe, goedkopere ontwerp doet precies hetzelfde als het originele perfecte ontwerp."

Het is alsof je een wiskundige hebt die bewijst dat je nieuwe, goedkopere bouwtekening 100% identiek is in functie aan het origineel, tot op het laatste atoom, voor elk mogelijk scenario, niet alleen voor de scenario's die je hebt getest.

4. De Optimalisatielus (De Slimme Renovator)

Zodra de AI een ontwerp heeft dat werkt, stopt het systeem niet. Het fungeert als een slimme renovator die naar de bouwtekening kijkt en zegt: "We kunnen dit huis 35% kleiner maken en 30% minder energie gebruiken."

De AI probeert de kamers (de schakellogica) te herschikken.
Het bouwt een nieuwe versie.
Het voert direct opnieuw de "Strikte Editor" uit om ervoor te zorgen dat de nieuwe versie nog steeds perfect werkt.
Vervolgens voert het een fysieke simulatie uit om te zien hoeveel ruimte en energie het bespaart.
Als de nieuwe versie beter is en wiskundig bewezen correct blijft, behoudt hij deze. Zo niet, dan draait hij terug.

De Resultaten

Het paper testte dit op honderden ontwerpproblemen (zoals het bouwen van tellers, geheugeneenheden en verkeerslichtcontrollers).

De Baseline (Oude Manier): Toen ze probeerden de chips te bouwen, faalden ongeveer 20% van de ontwerpen die op papier correct leken, daadwerkelijk toen ze probeerden ze te fabriceren.
CKTFORMALIZER (Nieuwe Manier): 100% van de ontwerpen die de strikte editor doorstonden, haalde het volledige fabricageproces (synthese, plaatsing en routing) zonder te falen.
Efficiëntie: Het systeem slaagde er ook in om de ontwerpen te verkleinen en aanzienlijk energie te besparen (tot 35% minder oppervlak) terwijl het bewees dat ze nog steeds perfect waren.

Samenvattend

CKTFORMALIZER is alsof je een AI-architect een magisch regelboek geeft dat hen verhindert fouten te maken voordat ze zelfs maar beginnen met tekenen. In plaats van een huis te bouwen en te hopen dat het niet instort, dwingt het de architect om te bewijzen dat het huis stevig is voordat de eerste baksteen wordt besteld. Dit verandert chipontwerp van een spelletje "gok en controleer" in een proces van "bewijs en bouw", wat resulteert in chips die kleiner, efficiënter zijn en gegarandeerd werken.

Technische Samenvatting: CktFormalizer

Probleemstelling

Hardwareontwerp blijft een foutgevoelige discipline waar subtiele gebreken, zoals bit-breedte-mismatches, combinatoire lussen of onvolledige caselogica in Finite State Machines (FSM's), syntaxiscontroles kunnen doorstaan maar tijdens synthese stilzwijgend falen of zich later manifesteren als kostbare siliciumbugs. Hoewel Large Language Models (LLM's) het vermogen hebben aangetoond om Verilog te genereren op basis van natuurlijke taal-specificaties, erft de resulterende code vaak de inherente valkuilen van Verilog en VHDL: een gebrek aan statische garanties zoals afhankelijke typen, exhaustieve patroonmatching en machine-gecontroleerde bewijzen. Bijgevolg vereist LLM-genererde hardware vaak uitgebreide handmatige debugging en faalt deze er vaak in om fysieke implementatie (Place-and-Route, DRC, LVS) te bereiken, zelfs wanneer deze functioneel correct is in simulatie.

Methodologie

Het artikel presenteert CktFormalizer, een raamwerk dat LLM-gedreven codegeneratie verenigt met formele verificatie door te richten op een afhankelijk-getypeerde Hardware Description Language (HDL) die is ingebed in Lean 4. In plaats van direct Verilog te genereren, leidt het systeem de LLM-agent om Lean-code te genereren, die dient als primaire compilatiedoel.

Kernarchitectuur

Het raamwerk werkt via een gesloten-luspijplijn waarbij Lean drie verschillende rollen vervult:

Typecontroleur (Compile-time Verifier): Het afhankelijke typesysteem van Lean codeert bit-breedte-beperkingen, casedekking en acycliciteit. Hardwaredefecten (bijvoorbeeld breedtemismatches of combinatoire lussen) worden opgevangen als compile-time typefouten in plaats van stilzwijgende backend-fouten. Dit biedt de LLM-agent directe, actieerbare feedback om het ontwerp iteratief te repareren.
Correctheidswaak: Ontwerpen die succesvol compileren in Lean zijn structureel gegarandeerd vrij van specifieke klassen van defecten (breedtemismatches, combinatoire lussen, onbedoelde latches). Dit zorgt ervoor dat gecompileerde ontwerpen de backend-synthese en de Place-and-Route (P&R)-stroom doorstaan zonder het 20% verliespercentage dat wordt waargenomen bij basislijn-Veriloggeneratie.
Bewijshulp: De agent bouwt geautomatiseerde theorembewijzen om functionele equivalentie te verifiëren tussen de specificatie in natuurlijke taal en de gegenereerde (of geoptimaliseerde) implementatie. Deze bewijzen bestrijken willekeurige invoersequenties en geparametriseerde breedtes, en gaan verder dan de beperkingen van gebonden SMT-gebaseerde controle.

Werkstroom

Generatie en Iteratie: Een LLM-agent (geïnstantieerd met Claude) genereert Lean HDL-code op basis van een specificatie in natuurlijke taal. Het komt in een iteratieve "genereer-compileer-repareer"-lus terecht waarbij Lean-compilerfouten de agent leiden om semantische bugs te herstellen voordat ze zich voortplanten.
Extractie: Na succesvolle compilatie extrahert een metaprogramma (#synthesizeVerilog) synthetiseerbare SystemVerilog uit de Lean Signaalcombinatorgraaf.
Fysieke Implementatie: Het geëxtraheerde SystemVerilog wordt gesimuleerd, gesynthetiseerd (met Yosys) en fysiek geïmplementeerd (met OpenROAD met de SkyWater 130nm PDK) om GDSII-layouts en Power-Performance-Area (PPA)-metrieken te genereren.
PPA-Optimalisatielus: Een gesloten-lus optimalisatiefase voert PPA-metrieken terug naar de agent. De agent stelt architecturale varianten voor (bijvoorbeeld parallelle versus seriële datapaden) en moet machine-gecontroleerde equivalentiebewijzen leveren om ervoor te zorgen dat de geoptimaliseerde variant functioneel equivalent blijft aan de oorspronkelijke specificatie.

Belangrijkste Bijdragen

Eerste End-to-End Raamwerk: CktFormalizer is het eerste raamwerk dat LLM-gedreven hardwaregeneratie combineert met een Lean-ingebedde HDL, en biedt een pijplijn van natuurlijke taal naar synthetiseerbaar silicium met gesloten-lus PPA-optimalisatie.
Typegeleide Generatie: Het artikel toont aan dat het richten op een typeveilige HDL de succespercentages van LLM's aanzienlijk verbetert in vergelijking met directe Veriloggeneratie. Compile-time typefouten bieden gestructureerde feedback die de agent naar correcte ontwerpen leidt, schaalbaar tot industrie-relevante IP zoals multi-kanaals handshake-businterfaces.
Integratie van Formele Verificatie: Het raamwerk overbrugt de kloof tussen LLM-genererde code en bewijsbaar correcte hardware door de agent in staat te stellen machine-gecontroleerde equivalentiebewijzen te produceren. Dit zorgt ervoor dat architecturale optimalisaties de functionele correctheid niet in gevaar brengen.

Experimentele Resultaten

Het raamwerk werd geëvalueerd op drie benchmarks: VerilogEval (156 problemen), RTLLM (50 problemen) en ResBench (56 problemen).

Backend Realiseerbaarheid: Een cruciale bevinding is dat CktFormalizer functionele correctheid door de backend behoudt. Waar de basislijn (directe Veriloggeneratie) ongeveer 20% van de functioneel correcte ontwerpen verliest tijdens synthese en routing, behoudt CktFormalizer 100% van zijn gecompileerde ontwerpen door de volledige synthese-, P&R-, DRC- en LVS-stroom.
Compilatie en Simulatie: Op VerilogEval behaalde CktFormalizer een Lean-compilatiepercentage van 92,3% en een RTL-simulatiepaspercentage van 72,4%, concurrerend met basislijnen voor directe Veriloggeneratie. Wanneer synthese-feedback wordt opgenomen in de agentlus, stijgt het compilatiepercentage naar 99,4%.
PPA-Optimalisatie: De gesloten-lus optimalisatiefase leverde aanzienlijke verbeteringen op. Door gevalideerde architectuurverkenning bereikte het raamwerk tot 35% oppervlaktevermindering en 30% vermogensreductie.
Timing Closure: Alle functioneel correcte ontwerpen die Place-and-Route voltooiden, bereikten timing closure (WNS $\ge$ 0 ns) zonder handmatige ingreep.
Bewijsgeneratie: In een proefstudie verbeterde stapsgewijze bewijsgeneratie (iteratieve verfijning met bewijsdoel-feedback) de bewijsvoltooiingspercentages van 53% naar 63%, wat de levensvatbaarheid van bewijshulpmiddelen voor hardwareverificatie aantoont.

Betekenis en Aanspraken

Het artikel stelt dat afhankelijke typen en LLM-agenten complementair zijn. Door een formele taal (Lean) te gebruiken als zowel het generatiedoel als het verificatiesubstraat, transformeert het raamwerk de "genereer-en-test"-lus van de LLM van een stochastische zoektocht naar syntactisch geldige programma's in een typegeleide verfijningsproces.

De auteurs benadrukken dat de compiler optreedt als de verificateur, en de foutdetectie verschuift van het einde van de EDA-pijplijn (waar correcties kostbaar zijn) naar compile-tijd. Deze aanpak stelt het systeem in staat hardware te produceren die niet alleen functioneel correct is, maar ook structureel robuust tegenover backend-transformaties, waardoor het probleem van het "stilzwijgende falen" dat gebruikelijk is bij LLM-genererde hardware effectief wordt opgelost. Het werk suggereert dat formele talen kunnen dienen als fundament voor betrouwbare, geautomatiseerde hardwareontwerp, waardoor LLM's de complexe afwegingen van hardwareoptimalisatie kunnen navigeren terwijl strenge correctheidsgaranties worden behouden.