💻 computer science

RubriQ: Rubric-Guided Group Relative Policy Optimization for Constraint-Aware Quantum Circuit Synthesis

RubriQ is een schaalbaar, door HPC gedreven framework dat rubric-gestuurde Group Relative Policy Optimization (GRPO) benut om de synthese van kwantumcircuits te automatiseren die gelijktijdig voldoen aan algoritmische correctheid, minimalisatie van de surface-code kosten en beperkingen van hardware voor de nabije toekomst.

Oorspronkelijke auteurs: Ziqing Guo, Ziwen Pan

Gepubliceerd 2026-08-03

📖 7 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Ziqing Guo, Ziwen Pan

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (https://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 machine probeert te bouwen die problemen kan oplossen die onmogelijk zijn voor elke computer die we vandaag de dag hebben. Deze machine is een kwantumcomputer, een apparaat dat de vreemde regels van minuscule deeltjes gebruikt om met lichtsnelheid wiskunde te bedrijven. Maar hier is de adder onder het gras: deze machines zijn ongelooflijk fragiel. Om ze te laten werken, moeten we onze grote, complexe ideeën vertalen naar een zeer specifieke, laag-niveau taal van "gates" (zoals schakelaars) die de machine begrijpt.

Het probleem is dat deze vertaling een nachtmerrie is. Als je simpelweg een standaardcomputer vraagt dit te doen, wordt de wiskunde zo enorm groot dat de boel crasht. Als je probeert de machine te bouwen met de technologie van vandaag, is het te luidruchtigig en foutgevoelig. Dus wetenschappers zitten vast in een tussenpositie: ze moeten circuits ontwerpen die perfect genoeg zijn voor de toekomstige supermachines, maar simpel genoeg om daadwerkelijk te draaien op de wankele prototypes van vandaag. Het is alsof je probeert een recept te schrijven voor een vijfsterrenbanket dat een peuter ook daadwerkelijk kan koken zonder de keuken af te branden.

Maak kennis met RubriQ, een nieuwe tool die fungeert als een superintelligente, onvermoeibare redacteur voor deze kwantumrecepten. In plaats van alleen maar te gokken en te controleren, gebruikt RubriQ een gigantische AI die leert door duizenden variaties tegelijkertijd te proberen, geleid door een strikte "rubriek" (een beoordelingsformulier) die precies vertelt hoe het moet verbeteren. Het zoekt niet alleen naar "goed genoeg"; het jaagt op de perfecte balans tussen wiskundig onberispelijk zijn en praktisch genoeg zijn om nu op echte hardware te draaien.

Het RubriQ-verhaal: Een AI leren een Kwantumarchitect te zijn

Denk aan het ontwerpen van een kwantumcircuit als het vragen aan een student om een verhaal te schrijven. In het verleden, als je een computer vroeg om een kwantumprogramma te schrijven, was dat alsof je een student een vage opdracht gaf zoals "Schrijf iets cools" en hoopte dat ze geen onzin uitkraamde. Als ze het fout deden, zei je alleen maar: "Nee, probeer het opnieuw," zonder enig idee waarom het fout was. Dit is wat oudere methoden deden: ze gaven een "sparse reward" (ijle beloning), wat betekent dat de AI pas een punt kreeg als het antwoord 100% perfect was, en nul punten voor de rest. Dit maakte het leren ongelooflijk traag en frustrerend, alsof je probeert te leren fietsen in het donker.

RubriQ verandert het spel door te fungeren als een strikte maar behulpzame leraar met een gedetailleerde beoordelingsrubriek. In plaats van alleen maar "Geslaagd" of "Gezakt" te zeggen, breekt het de beoordeling af in vijf specifieছে categorieën:

Werkt het? (Het verhaal is logisch).
Is het efficiënt? (Zijn er te veel woorden gebruikt? In kwantumtermen gaat dit over het minimaliseren van "T-gates", de dure, hulpbronnenverslindende onderdelen van de code).
Is het Clifford-zwaar? (Zijn er te veel fancy, moeilijk te maken bewegingen, of voornamelijk eenvoudige?).
Zal het draaien op de machines van vandaag? (Past het bij de specifieke vorm van de hardware, zoals het passen van een vierkante blok in een rond gat?).
Is het snel? (Hoeveel stappen neemt het?).

Het paper introduceert een methode genaamd Group Relative Policy Optimization (GRPO). Stel je voor dat de AI een chef is die een nieuw gerecht probeert uit te vinden. In plaats van één maaltijd te koken en te wachten op een recensie, vraagt RubriQ de chef om tegelijkertijd acht verschillende versies van het gerecht te bereiden. Vervolgens vergelijkt het deze met elkaar. Als één versie iets beter is dan de anderen, leert de AI om meer van dat soort te maken. Als er één een ramp is, leert de AI dat pad te vermijden. Deze "groepsvergelijking" is veel sneller en stabieler dan wachten op één enkel perfect antwoord.

Hoe ze de machine bouwden

Om dit werkend te krijgen, moesten de onderzoekers een enorme motor bouwen. Ze konden dit niet zomaar op een laptop draaien; het had de kracht nodig van NERSC Perlmutter, een supercomputercluster bij het Lawrence Berkeley National Laboratory. Ze gebruikten 8 NVIDIA A100 GPU's (de zware grafische kaarten die gebruikt worden voor AI) om de simulatie uit te voeren.

Hier is het slimme deel: de AI raadt niet alleen maar. Het gebruikt een programmatische rubriek. Dit betekent dat de "leraar" geen black-box neuraal netwerk is dat in de war kan raken; het is een set hardgecodeerde regels die de wiskunde, de kosten en de hardwarelimieten direct controleert. Als de AI een circuit genereert dat er cool uitziet maar de wiskunde niet klopt, geeft de rubriek het direct een nul. Als het een circuit genereert dat wel werkt maar te veel dure "T-gates" gebruikt, geeft de rubriek een lagere score, waardoor de AI wordt gestuurd om efficiënter te worden.

Ze losten ook een belangrijke flessenhals op: simulatiesnelheid. Het controleren of een kwantumcircuit werkt, vereist meestal het simuleren van het hele proces, wat exponentieel moeilijker wordt naarmate je meer qubits (kwantumbits) toevoegt. RubriQ integreert CUDA-Q, een tool waarmee ze deze simulaties direct op de GPU's kunnen draaien, wat het proces duizenden keren sneller maakt dan het draaien op een standaard CPU.

Wat ze vonden

De resultaten zijn veelbelovend, hoewel de auteurs voorzichtig zijn om ze te presenteren als een belangrijke stap voorwaarts in plaats van een wondermiddel.

Het werkt beter dan de oude manieren: Bij tests op 1.500 verschillende kwantumtaken behaalde RubriQ een slagenspercentage van 96% voor correctheid. Dat betekent dat bijna elke keer dat het probeerde, het een circuit produceerde dat de wiskunde daadwerkelijk goed uitvoerde.
Het is veel efficiënter: De belangrijkste metriek voor kwantumcomputers is de "T-count" (het aantal dure gates). RubriQ slaagde erin om het aantal van deze gates met gemiddeld 3,31 keer te comprimeren vergeleken met circuits die weliswaar "correct" waren maar niet geoptimaliseerd. Dit is een enorme zaak, want minder T-gates betekenen dat de computer minder middelen en minder tijd nodig heeft om te draaien.
Het leert sneller: Omdat het deze gedetailleerde rubrieken gebruikt in plaats van te wachten op een perfecte score, convergeerde RubriQ (leerde de taak) 2 tot 3 keer sneller dan andere reinforcement learning-methoden die afhankelijk zijn van sparse rewards.
Het is klaar voor echte hardware: Het team stopte niet bij simulaties. Ze namen de beste door RubriQ gegenereerde circuits en draaiden ze op echte kwantumcomputers van IBM en IonQ. Ze ontdekten dat de circuits compatibel waren met deze machines, met minder dan 1% overtreding van de hardwarebeperkingen.

Wat dit betekent

Het paper suggereert dat door kwantumcircuit-synthese te behandelen als een code-generatietaak geleid door een strikte, multidimensionale rubriek, we de creatie van hoogwaardige kwantumprogramma's kunnen automatiseren. Het voert een pleidooi tegen het idee dat we complexe, geleerde "critic" netwerken nodig hebben om het werk van de AI te beoordelen; in plaats daarvan werkt een helder, op regels gebaseerd scoringssysteem beter en is het goedkoper om te draaien.

Hoewel het paper niet beweert alle problemen van quantum computing te hebben opgelost, demonstreert het een levensvatbaar pad vooruit. Door de creatieve kracht van Large Language Models (LLM's) te combineren met de rigoureuze discipline van een programmatische rubriek, biedt RubriQ een manier om circuits te ontwerpen die niet alleen wiskundig solide zijn, maar ook praktisch genoeg om te draaien op de luidruchtige, imperfecte machines die we vandaag hebben, terwijl het tegelijkertijd voorbereiding treft op de fouttolerante reuzen van de toekomst. Het is een brug tussen de rommelige realiteit van de huidige hardware en de zuivere wereld van toekomstige kwantumcomputing.

Technische Samenvatting: RubriQ – Rubriek-gestuurde Group Relative Policy Optimization voor Constraint-bewuste Kwantumcircuit-synthese

1. Probleemstelling

De overgang naar schaalbare kwantumcomputing wordt geblokkeerd door het klassieke compilatieprobleem: het vertalen van algoritmen op hoog niveau naar gate-sequenties op laag niveau die zowel voldoen aan de randvoorwaarden voor fouttolerante kwantumcomputing (FTQC) als aan de uitvoerbaarheid op nabije-term hardware.

FTQC-randvoorwaarden: In surface-code architecturen vereisen niet-Clifford operaties (specifiek $T$ -gates) dure magic-state distillatie, wat orders van grootte meer fysieke middelen consumeert dan Clifford-gates. Het minimaliseren van de $T$ -count en $T$ -depth is cruciaal voor het verminderen van het klassieke computationele budget en de scheduling-complexiteit.
Nabije-term randvoorwaarden: Huidige Noisy Intermediate-Scale Quantum (NISQ) apparaten (bijv. IBM's heavy-hex topologie, IonQ's all-to-all connectiviteit) leggen strikte limieten op aan native gate sets, qubit-connectiviteit en circuit-diepte.
Beperkingen van bestaande methoden: Gangbare compilers (Qiskit, TKET) vertrouwen op statische heuristische regels en missen generatieve capaciteiten om nieuwe algebraïsche vereenvoudigingen te ontdekken. Eerdere Reinforcement Learning (RL) benaderingen lijden vaak aan ijle (sparse) terminale beloningen, hoog-variante gradiënten en smalle actieruimtes (gate insertie/verwijdering) die de ontdekking van structureel nieuwe circuits verhinderen. Bovendien is het trainen van RL-agenten voor kwantumsynthese op schaal computationeel onbetaalbaar vanwege de $O(4^{n_q})$ complexiteit van fidelity-simulatie.

2. Methodologie: Het RubriQ Framework

RubriQ herformuleert kwantumcircuit-synthese als een Large Language Model (LLM) code-generatie taak, geoptimaliseerd via Group Relative Policy Optimization zonder een geleerde waarde-functie critic.

2.1 LLM-als-Synthesizer

Het systeem behandelt de synthese van OpenQASM of Qiskit Python-code als een conditionele generatietaak.

Base Model: Een 7-miljard parameter instructie-getunede code-generatie LLM (Qwen2.5-Coder-7B) dient als de policy $\pi_\theta$ .
Parameter Efficiëntie: Het model wordt gefinetuned met behulp van Low-Rank Adaptation (LoRA) met rank 64, waarbij de trainbare parameters op ongeveer 0,4% van het totaal worden gehouden, wat implementatie op 4–8 NVIDIA A100 GPU's mogelijk maakt.
Generatie: Voor elke prompt (natuurlijke taal specificatie van een algoritme) samplet het model $N=8$ kandidaat-circuits autoregressief.

2.2 Rubriek-gestuurde Beloningsmotor

In plaats van een ijle binaire beloning of een neurale critic, gebruikt RubriQ een programmatische, multidimensionale rubriek om dichte, deterministische beloningen te genereren. De beloningsfunctie $R(y)$ is een gewogen som van vijf begrensde component-scores ( $S_d \in [0, 1]$ ), gegateerd door een harde correctievoorwaarde:
$R(y) = g(c) \cdot [w_F S_F + w_C S_C + w_T S_T + w_H S_H + w_E S_E]$
Waarbij $g(c)$ een harde gate is die de beloning op nul zet als de gemiddelde gate-fidelity $F_{avg} < 0,99$ .

De vijf dimensies zijn:

Functionele Fidelity ( $S_F$ ): Gemeten via de Hilbert-Schmidt inwendige product tegen de doel-unitaire matrix.
Clifford Fractie ( $S_C$ ): De ratio van Clifford gates tot het totaal aantal operationele gates, wat Clifford-zware circuits stimuleert.
$T$ -Count Reductie ( $S_T$ ): Een exponentieel verval-score gebaseerd op de totale equivalente $T$ -gate count (rekening houdend met decomposities van Toffoli en arbitraire rotaties).
Nabije-term Hardware Validatie ( $S_H$ ): Een score die de compatibiliteit met specifieke backends evalueert (IBM Eagle/Heron, IonQ Forte/Aria), waarbij non-native gates en SWAP routing overhead worden bestraft.
Circuit Efficiëntie ( $S_E$ ): Een diepte-genormaliseerde compactheid-metriek.

2.3 GRPO Trainingslus

Het framework maakt gebruik van Group Relative Policy Optimization (GRPO), wat de noodzaak voor een aparte waarde-functie critic elimineert.

Advantage Estimatie: Voor een groep $N$ completions gesampled uit dezelfde prompt, worden advantages $\hat{A}_i$ berekend door de beloningen binnen de groep te normaliseren: $\hat{A}_i = (R_i - \mu_R) / (\sigma_R + \epsilon)$ .
Schaalbaarheid: Deze aanpak vermindert de variantie van gradiënt-schattingen vergeleken met ijle beloningen en vermijdt de geheugen/communicatie-bottlenecks van het onderhouden van een multi-miljard-parameter critic over gedistribueerde GPU's.
HPC Integratie: De trainingslus integreert GPU-versnelde CUDA-Q simulatie direct in de RL-lus voor hoog-doorvoers fidelity-evaluatie. Het systeem wordt uitgerold op NERSC Perlmutter met DeepSpeed ZeRO-2 voor gedistribueerde gradiënt- en optimizer-state partitionering.

3. Belangrijkste Bijdragen

LLM-als-Synthesizer Formulering: De eerste toepassing van miljarden-schaal instructie-getunede LLM's voor gate-level kwantumsynthese met behulp van RL-gebaseerde post-training, bewegend voorbij kleine transformer-modellen of statische heuristieken.
Multi-Objectieve Rubriek Beloningsmotor: Een domein-gegronde scoring-system dat FTQC kosten-metrieken (Clifford+T) scheidt van nabije-term hardware validatie, waardoor neurale critics worden vervangen door interpreteerbare, deterministische rubrieken.
Schaalbare HPC Systemen Architectuur: Een volledige trainings-pipeline geïmplementeerd op NERSC Perlmutter met >85% strong-scaling efficiëntie over 8 A100 GPU's, gebruikmakend van DeepSpeed ZeRO-2 en CUDA-Q om de computationele kosten van $O(4^{n_q})$ simulaties te beheren.
Nabije-term Hardware Validatie: Een geautomatiseerde pipeline die gesynthetiseerde circuits valideert op fysieke IBM Heron-3 en IonQ Forte processoren, wat de uitvoerbaarheid buiten simulatie aantoont.
Empirische Prestaties: Demonstreert significante verbeteringen in synthesekwaliteit en convergentiesnelheid vergeleken met sparse-reward baselines en traditionele compilers.

4. Experimentele Resultaten

Geëvalueerd op 1.500 benchmark circuits (QFT, QPE, Hamiltonian simulatie, data encoding) over 2–8 qubits:

Correctheid: Bereikte een per-dataset correctheid pass-rate van ten minste 96%.
$T$ -Gate Compressie: Behaalde een gemiddelde $T$ -gate compressie van 3,31 $\times$ over correct-only circuits, wat significant beter presteert dan sparse-reward RL baselines (2,05 $\times$ ) en traditionele tools (TKET, Qiskit).
Convergentie: De rubriek-gestuurde aanpak convergeerde 2–3 $\times$ sneller dan sparse-reward baselines, waardoor het totale aantal trainingsepochs werd verminderd.
Constraint Violaties: Handhaafde minder dan 1% nabije-term hardware constraint violaties.
Hardware Validatie: Succesvol de top-k circuits uitgerold op IBM Heron-3 en IonQ Forte, wat de bekwaamheid van de pipeline bevestigt om hardware-bewuste code te genereren.
Computationele Efficiëntie: De dichte rubriek-shaping reduceerde het totaal aantal simulatie-aanroepen met 2–3 $\times$ vergeleken met sparse-reward methoden, wat vertaalt naar significante GPU-uur besparingen (bijv. 9,2 vs. 24,2 GPU-uren voor 8-qubit taken).

5. Betekenis en Claims

Het paper stelt dat RubriQ een nieuw paradigma vestigt voor geautomatiseerde kwantumcircuit-synthese door LLM generatieve capaciteiten te verenigen met rigoureuze, domeinspecifieke randvoorwaarden.

Scheiding van Zorgen: Door de FTQC kosten-metrieken expliciet te scheiden van nabije-term hardware validatie, adresseert RubriQ de conflicterende eisen van toekomstige fouttolerante systemen en huidige NISQ-apparaten.
Eliminatie van de Critic: Het werk demonstreert dat voor deterministische, programmatisch berekenbare taken zoals kwantumsynthese, een geleerde waarde-functie critic niet nodig is; dichte, rubriek-gebaseerde beloningen gecombineerd met GRPO bieden voldoende signaal voor effectieve policy optimalisatie.
HPC-gestuurde Pipeline: Het onderzoek benadrukt de noodzaak van High-Performance Computing (HPC) middelen voor het trainen van AI-gestuurde kwantumtools, en biedt een blauwdruk voor het schalen van RL-gebaseerde synthese naar grotere qubit-aantallen waar klassieke simulatie onuitvoerbaar wordt.
Robuustheid: Het framework is aangetoond robuust te zijn over verschillende algoritmische families en qubit-aantallen, waarbij overfitting op specifieke circuit-templates wordt voorkomen.

De auteurs concluderen dat RubriQ een geautomatiseerde, hoog-presterende pipeline biedt voor het genereren van surface-code-kosten-bewuste circuits, waarmee de kloof tussen theoretisch algoritme-ontwerp en praktische hardware-executie wordt overbrugd.