⚛️ quantum physics

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) met GPU-versnelde simulatie benut om automatisch fouttolerante kwantumcircuits te synthetiseren die significante T-gate compressie bereiken terwijl ze strikt voldoen aan hardwarebeperkingen en een hoge fidelity behouden.

Oorspronkelijke auteurs: Ziqing Guo, Ziwen Pan

Gepubliceerd 2026-07-09

📖 4 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Ziqing Guo, Ziwen Pan

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 complexe machine probeert te bouwen met een zeer specifieke, dure en breekbare set Lego-steentjes. Je hebt een meesterontwerp (het algoritme dat je wilt draaien), maar de instructies die je hebt zijn geschreven in een vage, hoogwaardige taal zoals "bouw een vliegende auto."

Het probleem is dat de fabrieksvloer (de quantumcomputer) strikte regels heeft:

De steentjes zijn zeldzaam: Eén specif kind type steentje (de "T-gate") is ontzettend duur om te maken. Je wilt er zo min mogelijk gebruiken.
De lay-out is vreemd: Sommige machines (zoals die van IBM) laten je alleen steentjes verbinden die direct naast elkaar liggen. Anderen (zoals die van IonQ) laten je elke steen met elke andere steen verbinden.
Het doel: Je moet dat vage idee van een "vliegende auto" omzetten in een nauwkeurige, stapsgewijze handleiding die zo min mogelijk dure steentjes gebruikt en daarbij de lay-outregels van de fabriek respecteert.

RubriQ is een nieuw systeem dat ontworpen is om dit puzzelstukje automatisch op te lossen. Zo werkt het, onderverdeeld in eenvoudige concepten:

1. De "Slimme Schrijver" (Het LLM)

In plaats van een rigide computerprogramma dat een vaste lijst met regels volgt, gebruikt RubriQ een Large Language Model (LLM). Denk aan dit als een zeer slimme, creatieve schrijver die miljoenen instructiehandleidingen heeft gelezen.

Je geeft de schrijver een opdracht: "Schrijf een quantumcircuit voor een 4-qubit Fourier Transformatie."
De schrijver probeert de code te genereren. Soms schrijft hij perfecte code; soms schrijft hij onzin of laat hij stappen weg.

2. De "Strenge Docent" (De Rubriek)

In het verleden, wanneer AI werd getraind om dit te doen, zei de computer alleen "Goed gedaan" of "Slecht gedaan" aan het einde. Dit is als een docent die pas bij het eindexamen zegt dat een student is gezakt, zonder uit te leggen waarom. Dit maakt leren traag en frustrerend.

RubriQ introduceert een Rubriek, wat lijkt op een gedetailleerde beoordelingsmatrix die een docent gebruikt. In plaats van een simpele "Geslaagd/Gezakt", controleert het systeem de gegenereerde code op vijf specifieke dimensies:

Clifford Score: Heb je de goedkope, veelvoorkomende steentjes gebruikt?
T-Count Score: Heb je de dure, zeldzame steentjes geminimaliseerd?
Hardware Score: Past deze code daadwerkelijk op de specifieke machine (IBM of IonQ) die je target?
Fidelity Score: Doet de machine daadwerkelijk wat je hebt gevraagd?
Efficiency Score: Is de instructiehandleiding kort en overzichtelijk?

Het systeem geeft de AI een score voor elk van deze gebieden. Dit levert een "dicht" signaal op — veel feedback — zodat de AI precies weet welke delen van zijn code hij moet aanpassen, in plaats van te moeten gokken.

3. De "Groepscompetitie" (GRPO)

Om de AI te onderwijzen, gebruikt RubriQ een methode genaamd Group Relative Policy Optimization (GRPO).

Stel je voor dat je de AI 8 keer achter elkaar vraagt het probleem op te lossen.
Je hebt geen aparte "rechter"-AI nodig om te vertellen welke het beste is. In plaats daarvan vergelijk je de 8 antwoorden simpelweg met elkaar.
De winnaar met de hoogste rubriekscore krijgt een "duim omhoog", en de verliezers met lagere scores krijgen een "duim omlaag".
De AI leert door naar de winnaars en verliezers binnen zijn eigen groep te kijken en past zijn schrijfstijl aan om de volgende keer meer "winnaars" te produceren.

4. De "Superfabriek" (HPC)

Het trainen van deze AI is een enorme klus. Het simuleren van quantumcircuits is also[f] het berekenen van het weer voor elke mogelijke toekomst tegelijkertijd; het vereist enorme rekenkracht.

De onderzoekers draaiden dit op NERSC Perlmutter, een supercomputer met honderden krachtige grafische kaarten (GPU's).
Ze bouwden een pijplijn waarbij de AI code genereert, een parser controleert of het leesbaar is, en een simulator het draait op de "virtuele fabrieksvloer" om de scores te controleren.
Omdat ze de "Rubriek"-methode gebruikten, leerde de AI 2 tot 3 keer sneller dan eerdere methoden die vertrouwden op vage "Geslaagd/Gezakt"-signalen.

De Resultaten

Toen ze RubriQ testten:

Het bespaarde middelen: Het slaagde erin om het aantal dure "T-gates" gemiddeld 3,3 keer te verminderen vergeleken met standaardtools.
Het was accuraat: De circuits die het schreef, werkten daadwerkelijk wanneer ze werden getest op echte quantumcomputers van IBM en IonQ.
Het was efficiënt: Het bereikte zijn doelen in minder trainingsstappen, wat enorme hoeveelheden elektriciteit en computertijd bespaarde.

Kortom: RubriQ is een systeem dat een creatieve AI-schrijver leert hoe hij quantumcircuits bouwt door hem een gedetailleerde checklist (de rubriek) te geven en hem te laten leren door zijn eigen pogingen met elkaar te vergelijken, alles draaiend op een enorme supercomputer om ervoor te zorgen dat de resultaten klaar zijn voor echte quantummachines.

Technische Samenvatting: RubriQ – Rubric-Guided Group Relative Policy Optimization voor Constraint-Aware Quantum Circuit Synthese

1. Probleemstelling

De synthese van fouttolerante kwantumcircuits (FTQC) die zowel algoritmisch correct als hardware-compatibel zijn, vormt een kritieke flessenhals in schaalbare kwantumcomputing. De primaire uitdagingen zijn:

Resource Overhead: In FTQC vereisen niet-Clifford operaties (specifiek T-gates) magic-state distillatie, wat ordes van grootte meer fysieke resources consumeert dan Clifford-gates. Het minimaliseren van de T-count is essentieel voor het verminderen van de distillatie-overhead en de scheduling-complexiteit.
Hardwarebeperkingen: Near-term apparaten leggen strikte topologische en native gate-beperkingen op (bijv. IBM's heavy-hex connectiviteit versus IonQ's all-to-all connectiviteit), wat vereist dat circuits efficiënt worden getranspiled om excessieve SWAP-overhead te voorkomen.
Beperkingen van Bestaande Methoden:
- Heuristische Compilers (bijv. Qiskit, TKET) vertrouwen op statische herschrijfregels en missen het generatieve vermogen om nieuwe algebraïsche vereenvoudigingen te ontdekken.
- Standaard Reinforcement Learning (RL) benaderingen lijden vaak aan sparse terminal rewards, wat leidt tot hoog-variante gradiënten en slechte exploratie. Ze opereren doorgaans op smalle actieruimtes (gate insertie/verwijdering) in plaats van circuits vanaf nul te genereren.
- Neural Critics: Het trainen van multi-billion parameter critic-netwerken voor RL introduceert ernstige geheugen- en communicatie-bottlenecks in high-performance computing (HPC) omgevingen.

2. Methodologie: Het RubriQ Framework

RubriQ herformuleert kwantumcircuit-synthese als een gestructureerde code-generatietaak voor Large Language Models (LLMs), geoptimaliseerd via Group Relative Policy Optimization zonder een geleerde waarde-functie critic.

A. LLM-als-Synthesizer

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

Input: Natuurlijke taal prompts die doelalgoritmen specificeren (bijv. QFT, Hamiltonian simulatie) en beperkingen.
Model: Een 7B-parameter instructie-getunede code LLM (Qwen2.5-Coder-7B) gefinetuned met Low-Rank Adaptation (LoRA).
Generatie: De policy samplet $N=8$ kandidaat-circuits per prompt middels autoregressieve sampling.
Parsing: Een multi-strategie parser extraheert uitvoerbare circuit-objecten uit de ruwe tekstoutput van de LLM. Niet-parseerbare outputs krijgen onmiddellijk een reward van nul.

B. Rubric-Guided Reward Engine

In plaats van een neurale critic gebruikt RubriQ een deterministische, programmele score-engine die circuits evalueert over vijf orthogonale dimensies. De totale reward $R(y)$ is een gewogen som:
$R(y) = w_C S_C + w_T S_T + w_H S_H + w_F S_F + w_E S_E$

Clifford Fraction ( $S_C$ ): De proportie gates die Clifford-operaties zijn (efficiënt te simuleren).
T-Count Reduction ( $S_T$ ): Een exponentiële vervalfunctie die hoge T-gate counts bestraft, waarbij prioriteit wordt gegeven aan het elimineren van de eerste paar T-gates vanwege de gebatteerde aard van distillatie.
Hardware Compatibiliteit ( $S_H$ ): Evalueert naleving van specifieke backend-topologieën (bijv. IBM Heavy-Hex, IonQ All-to-All), waarbij SWAP routing-overhead en niet-native gates worden bestraft.
Functionele Getrouwheid ( $S_F$ ): Berekent de process fidelity via de Hilbert-Schmidt inner product tussen de gegenereerde unitaire matrix en het doelalgoritme, wat de algoritmische correctheid waarborgt.
Circuit Efficiëntie ( $S_E$ ): Beloont compactheid en een lagere circuit diepte.

C. GRPO Trainingsloop

RubriQ maakt gebruik van Group Relative Policy Optimization (GRPO) om de policy te updaten:

Group Normalization: Voor een gegeven prompt worden de rewards van de $N$ gesamplede completions genormaliseerd door de groepsmiddelde af te treken en te delen door de groep standaarddeviatie.
Critic-Vrij: Deze aanpak elimineert de noodzaak voor een geleerde waarde-functie, door te vertrouwen op de dichte, deterministische signalen geleverd door de rubric.
Advantage Estimatie: De genormaliseerde advantage $\hat{A}_i$ stuurt de policy gradient updates aan, waardoor het model kan leren van gegradeerde feedback in plaats van sparse binaire succes/falen signalen.

D. HPC Systemen Architectuur

Om de computationele kosten van fidelity simulatie te beheersen (schalend als $O(4^{n_q})$ ), is RubriQ uitgerold op de NERSC Perlmutter supercomputer:

Hardware: NVIDIA A100 (80 GB) clusters verbonden via Slingshot-11.
Optimalisatie: Gebruikt DeepSpeed ZeRO-2 voor gedistribueerde gradiënt- en optimizer state partitioning.
Simulatie: Integreert GPU-versnelde CUDA-Q simulatie direct in de RL-loop voor high-throughput fidelity evaluatie.
Efficiëntie: Bereikt >85% strong-scaling efficiëntie over 8 GPU's.

3. Belangrijkste Bijdragen

LLM-als-Synthesizer Formulering: De eerste toepassing van miljarden-schaal, instructie-getunede LLM's voor gate-level kwantumsynthese met RL-gebaseerde post-training, bewegend voorbij kleine transformer-modellen of heuristische regels.
Multi-Objective Rubric Reward Engine: Een innovatieve vervanging voor neurale critics, bestaande uit een domein-gegrond, interpreteerbaar score-systeem dat dichte, begrensde rewards biedt over Clifford, T-count, hardware, fidelity en efficiëntie dimensies.
Schaalbare HPC Architectuur: Een volledige training pipeline implementatie op NERSC Perlmeter die strong scaling demonstreert en het totaal aantal simulatie-calls met 2–3× vermindert vergeleken met sparse-reward baselines door snellere convergentie.
Hardware-Gevalideerde Evaluatie: Succesvolle deployment van gesynthetiseerde circuits op fysieke IBM Heron-3 en IonQ Forte processors via een geautomatiseerde transpilation pipeline.
Experimentele Prestaties: Gedemonstreerd superieur rendement over 1.500 benchmark circuits, waarbij significante T-gate compressie en snellere convergentie worden bereikt ten opzichte van bestaande baselines.

4. Resultaten

T-Gate Compressie: RubriQ bereikt een gemiddelde T-gate compressie van 3.31× over benchmark datasets, wat de sparse-reward RL baselines (2.05×) en regelgebaseerde compilers (Qiskit O3: ~1.4×, TKET O2: ~1.7×) significant overtreft.
Convergentiesnelheid: Het framework convergeert 2–3× sneller dan sparse-reward RL methoden, waarbij minder trainingsepochs nodig zijn om doelcompressie-rates te bereiken.
Resource Efficiëntie: Door de snellere convergentie vermindert RubriQ de totale GPU-uren met ongeveer 2.6× vergeleken met de Sparse-PPO en Sparse-GRPO baselines.
Constraint Naleving: Het systeem handhaaft minder dan 1% hardware-constraint schendingen en bereikt een hoge functionele getrouwheid (>99% in veel gevallen).
Hardware Validatie: De best gerangschikte circuits werden succesvol uitgevoerd op IBM en IonQ hardware, wat de praktische toepasbaarheid buiten simulatie bevestigt.

5. Betekenis en Claims

Het artikel claimt dat RubriQ een nieuw paradigma vestigt voor geautomatiseerde wetenschappelijke ontdekking in kwantumcomputing door LLM-gestuurde code-generatie te verenigen met verifieerbare, rubric-gebaseerde reinforcement learning. De betekenis ligt in:

Schaalbaarheid: Het bewijzen dat LLM-gebaseerde synthese naar HPC-omgevingen geschaald kan worden om de exponentiële complexiteit van kwantumcircuit optimalisatie op te lossen.
Constraint Awareness: Het succesvol adresseren van de dubbele eisen van FTQC-gereedheid (T-count minimalisatie) en near-term hardware compatibiliteit (topologie beperkingen) binnen één enkele optimalisatie framework.
Efficiëntie: Het demonstreren dat dichte, programmele reward shaping computationeel superieur is aan sparse rewards en neurale critics voor dit domein, wat het mogelijk maakt om grote modellen te trainen op realistische kwantum workloads.
Practicaliteit: Het valideren dat AI-gegenereerde circuits niet alleen theoretisch optimaal zijn, maar ook uitvoerbaar op de huidige generatie kwantum hardware.

De auteurs positioneren RubriQ als een cruciale stap richting geautomatiseerde, high-performance computing-gestuurde pipelines voor het genereren van fouttolerante, hardware-ready kwantumcircuits op schaal.