⚛️ quantum physics

End-to-End Fidelity Analysis of Quantum Circuit Optimization: From Gate-Level Transformations to Pulse-Level Control

Dit artikel presenteert een open-source framework dat een C++ circuitoptimizer koppelt aan een gevalideerd Lindblad-getrouwheidsmodel, waarbij door middel van uitgebreide benchmarking en uitvoering op echte hardware wordt aangetoond dat het aantal twee-qubit gates de primaire voorspeller is van procesgetrouwheid en dat hoewel het model de moeilijkheidsgraad van circuits nauwkeurig rangschikt, het de absolute getrouwheid systematisch overschat vanwege niet-gemodelleerde foutbronnen zoals crosstalk en lekkage.

Oorspronkelijke auteurs: Rylan Malarchick

Gepubliceerd 2026-06-23

📖 6 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Rylan Malarchick

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 delicate boodschap over een stormachtige oceaan probeert te sturen. De boodschap is geschreven op een kwetsbaar stuk papier (het kwantumcircuit), en de oceaan is vol golven en wind die het papier uit elkaar willen scheuren (ruis en decoherentie).

Dit papier gaat over het bouwen van de beste mogelijke boot en navigatiesysteem om die boodschap de overkant te krijgen zonder dat deze wordt verpest. De auteur, Rylan Malarchick, heeft een "simulator" gebouwd om verschillende bootontwerpen te testen en heeft ze vervolgens daadwerkelijk op een echt schip gevaren om te zien of de simulator de waarheid sprak.

Hier is de uitsplitsing van wat hij heeft gevonden, met behulp van eenvoudige analogieën:

1. Het Probleem: De "Vuilniswagen" versus de "Sportwagen"

Wanneer je een kwantumprogramma schrijft, komt er vaak veel onnodige bagage bij. Het is alsof je een koffer inpakt met zware stenen die je niet nodig hebt.

De Simulator: De auteur heeft een computerprogramma gebouwd dat fungeert als een "natuurkundig laboratorium". Het neemt een kwantumcircuit, verwijdert de onnodige onderdelen en berekent vervolgens precies hoeveel de "storm" (ruis) de boodschap zal beschadigen op basis van hoe lang de reis duurt en hoeveel zware bochten de boot moet maken.
De Realiteitscheck: Om er zeker van te zijn dat de simulator niet alleen maar gokte, heeft hij 8 specifieke reizen uitgevoerd op een echte kwantumcomputer (de IQM Garnet processor) en de resultaten vergeleken met wat de simulator voorspelde.

2. De Grote Ontdekking: "Annuleren" is Koning

De auteur testte vier verschillende manieren om het circuit op te schonen (optimalisatie-passes).

De Analogie: Stel je voor dat je een pad bewandelt.
- Pass A: Je loopt vooruit, en loopt dan direct weer achteruit. (Dit is een "Gate Cancellation").
- Pass B: Je wisselt de volgorde van twee dingen die elkaar niet beïnvloeden.
- Pass C: Je combineert twee kleine stappen tot één grote stap.
- Pass D: Je verwijdert stappen die niets doen.
Het Resultaat: De studie vond dat Pass A (Annuleren) bijna al het zware werk doet. Het verwijderde 72% van de onnodige stappen en zorgde voor bijna de gehele verbetering. De andere drie passes waren als het polijsten van een auto die nog steeds een lekke band heeft; ze hielpen een klein beetje, maar ze waren niet de game-changer.
De Les: Als je een kwantumprogramma wilt repareren, zoek dan gewoon naar stappen die elkaar ongedaan maken en verwijder ze. Dat is het belangrijkste om te doen.

3. De Metrische Valstrik: "Totaal aantal stappen" tellen versus "Zware stappen" tellen

Veel mensen vergelijken kwantumcomputers door het totaal aantal stappen (gates) in een programma te tellen. De auteur zegt dat dit misleidend is.

De Analogie: Stel je een bezorgwagen voor.
- Single-qubit gates zijn als het bezorgen van een brief. Ze zijn snel en licht.
- Two-qubit gates zijn als het bezorgen van een vleugel. Ze zijn traag, zwaar en de kans is veel groter dat ze beschadigd raken of kapotgaan.
De Bevinding: Eén populaire software (Qiskit) beweerde het totaal aantal stappen met 47% te hebben verminderd. Dat klinkt geweldig! Maar toen de auteur beter keek, zag hij dat Qiskit vooral de "brieven" (lichte stappen) had verwijderd en bijna alle "vleugels" (zware stappen) ongemoeid had gelaten.
De Realiteit: De tool van de auteur verminderde niet zoveel totale stappen, maar verwijderde veel meer "vleugels" (two-qubit gates). Omdat de "vleugels" degene zijn die de boodschap daadwerkelijk beschadigen, produceerde de tool van de auteur een veel beter resultaat voor de echte machine, zelfs als het totaal aantal stappen lager leek op de tool van de ander.

4. Tijd is de Vijand

De studie vond dat hoe langer de boot in de storm blijft, hoe groter de kans dat de boodschap nat wordt.

De Bevinding: De duur van de reis (pulse duration) en de grootte van het circuit waren de sterkste voorspellers van falen.
De Analogie: Als je een rivier moet oversteken, maakt het niet uit of je een kortere route neemt die je 5 seconden bespaart als de brug wankel is. Maar als je een route neemt die 10 seconden langer duurt, heeft het water 10 seconden langer de tijd om je nat te spuiten. De studie toonde aan dat het verminderen van de totale tijd op het water de meest effectieve manier is om de boodschap veilig te houden.

5. De Volgorde Maakt (Niet Veel) Uit

De auteur vroeg zich af of de volgorde waarin ze de schoonmaakstappen toepasten uitmaakte.

De Bevinding: Dat maakte niet uit. Of je nu eerst de "brieven" of de "vleugels" schoonmaakte, het resultaat was hetzelfde.
De Les: Je hoeft geen genie te zijn om de perfecte volgorde van handelingen te bedenken. Zolang je de "Annuleer"-tool in je gereedschapskist hebt, kun je die wanneer je maar wilt gebruiken.

6. De "Optimisme-kloof"

Toen ze de voorspellingen van de simulator vergeleken met het echte schip (de IQM hardware), was de simulator altijd te optimistisch.

De Analogie: De simulator voorspelde dat de boodschap voor 90% intact zou aankomen. In werkelijkheid kwam hij slechts voor 40% intact aan.
De Reden: De simulator was erg goed in het berekenen van de "golven" (standaard ruis), maar hield geen rekening met "lekken" in de romp, "crosstalk" (golven die tegen het verkeerde deel van de boot slaan) of "leesfouten" (de ontvanger die de boodschap verkeerd leest).
De Waarde: Hoewel de simulator niet perfect was, was hij wel consistent. Hij voorspelde correct welke reizen moeilijker zouden zijn dan andere. Het is als een weervoorspelling die altijd 10 graden te warm is, maar nog steeds correct vertelt dat dinsdag warmer zal zijn dan maandag.

Samenvatting

Het papier vertelt ons drie belangrijke dingen voor iedereen die kwantumcomputers bouwt of gebruikt:

Annuleer Gewoon: De meest effectieve manier om een kwantumprogramma te verbeteren is door stappen te vinden en te verwijderen die elkaar opheffen.
Tel het Zware Spul: Tel niet alleen hoeveel stappen een programma heeft; tel hoeveel "zware" (two-qubit) stappen het heeft. Dat is wat er echt toe doet.
Snelheid Maakt Uit: Hoe sneller je het programma voltooid krijgt, hoe kleiner de kans dat het faalt.

De auteur heeft al zijn tools en data gratis vrijgegeven, zodat iedereen deze "natuurkundige lab" kan gebruiken om zijn eigen kwantumprogramma's te testen.

Technische Samenvatting: End-to-End Fidelity Analyse van Quantum Circuit Optimalisatie

Probleemstelling

De fidelity van quantumberekeningen op Near-Term Noisy Intermediate-Scale Quantum (NISQ) apparaten wordt beperkt door gate-fouten, decoherentie en compilatie-overhead. Hoewel er aanzienlijk onderzoek is gedaan naar gate-niveau optimalisatiepasses (bijv. peephole optimalisatie, globale herschrijving), blijft de end-to-end impact van deze transformaties op de fysieke, pulse-niveau fidelity onvoldoende gekarakteriseerd. Huidige vergelijkingen tussen compilers vertrouwen vaak op misleidende metrieken, zoals het totale aantal gates, die geen onderscheid maken tussen single-qubit en two-qubit operaties. Aangezien two-qubit gates de foutenbudget domineren op supergeleidende processors, vertaalt een reductie in het totale aantal gates zich niet noodzakelijkerwijs in verbeterde hardwareprestaties. Bovendien worden optimalisatiestrategieën vaak geïsoleerd geëvalueerd, waarbij de interactie tussen gate-niveau beslissingen en de fysieke executie-fidelity wordt genegeerd.

Methodologie

De auteurs presenteren qco-integration, een end-to-end framework dat een hoogwaardige C++ circuit optimizer verbindt met een per-gate Lindblad fidelity model. Het systeem werkt via een vijfstaps pijplijn:

Parse en Valideer: Input circuits in OpenQASM 3.0 worden geparst en gevalideerd.
Optimaliseer: Een C++ optimizer past een configureerbare sequentie van vier passes toe: Gate Cancellation, Commutation Analysis, Rotation Merging en Identity Elimination.
Route: Het SABRE-algoritme brengt logische qubits in kaart naar fysieke hardwaretopologieën (specifiek de IQM Garnet heavy-hex layout), waarbij indien nodig SWAP gates worden ingevoegd.
Pulse Compile: Native gates (PRX, CZ) worden gecompileerd naar microwave pulse sequenties met gekalibreerde duur (20 ns voor single-qubit, 40 ns voor two-qubit).
Simuleer: Een per-gate Lindblad master equation model berekent ruisende kanalen. In tegenstelling tot volledige circuit-simulaties, lost deze aanpak de vergelijking op voor één- of twee-qubit subspaces voor elke gate, waarbij de resultaten worden samengesteld. Het model bevat $T_1/T_2$ relaxatie, pure dephasing, en een gekalibreerd depolariserend kanaal.

Het framework werd geëvalueerd over 371 benchmark circuits (GHZ, QFT, QAOA, en Random) met in totaal 4.452 experiment runs. De studie omvatte:

Ablatie-studies: Evaluatie van individuele passes, leave-one-out analyse, en pass-volgorde gevoeligheidstests.
Compiler Vergelijking: Het benchmarken van de aangepaste optimizer (QCO) tegen Qiskit transpilatieniveaus (L0–L3) gericht op zowel virtuele als IQM-native basis gates.
Hardware Validatie: Executie van acht representatieve circuits op de IQM Resonance Garnet 20-qubit processor om gesimuleerde voorspellingen te vergelijken met gemeten fidelity.

Belangrijkste Bijdragen

Modulaire Integratie Architectuur: Een ontkoppeld systeem dat C++ optimalisatie verbindt met Python-gebaseerde pulse-niveau analyse via OpenQASM en JSON.
Per-Gate Lindblad Fidelity Model: Een schaalbaar model dat cross-valideert met qiskit-dynamics en lineair schaalt met het aantal gates, wat analyse van grote circuit corpora mogelijk maakt.
Systematische Ablatie Studie: Een formele evaluatie van optimalisatiepasses met behulp van Cohen's $d$ effectgroottes en Kruskal–Wallis tests om bijdragen en ordeningseffecten te isoleren.
Hardware-Relevante Metrieken: Een demonstratie dat het aantal two-qubit gates, in plaats van het totale aantal gates, de juiste metriek is voor het vergelijken van compiler effectiviteit op supergeleidende hardware.
Hardware Benchmarking: Een geprovenance benchmark op IQM Garnet (8/8 jobs voltooid) die de kloof tussen simulatie en realiteit kwantificeert.

Resultaten

Effectiviteit van Optimalisatie

Dominantie van Cancellation: Gate cancellation is de primaire drijfveer voor verbetering, waarbij 3.780 gates over de gehele corpus werd verwijderd en 72,0% van de circuits werd verbeterd. Het is verantwoordelijk voor een grote effectgrootte ( $d=1.66$ ).
Marginale Rol van Andere Passes: Rotation merging, commutation en identity elimination vertoonden verwaarloosbare effecten in isolatie ( $d < 0.2$ ).
Pass Volgorde: De volgorde van de vier passes heeft geen statistisch significant effect op de optimalisatie-uitkomsten (Kruskal–Wallis $p=0.302$ ).

Fidelity Predictoren

Negatieve Correlaties: Circuitgrootte (input gates, $r=-0.78$ ) en pulse duur (pulse duration, $r=-0.73$ ) zijn de sterkste negatieve voorspellers van proces fidelity ( $R^2=0.53$ ).
Ruis Gevoeligheid: Het relatieve voordeel van optimalisatie neemt toe met de ernst van de ruis, wat een relatieve fidelity verbetering van 50% oplevert in zeer hoog-ruis regimes vergeleken met 8% in laag-ruis regimes.

Compiler Vergelijking (QCO vs. Qiskit)

Two-Qubit Reductie: QCO behaalde een superieure two-qubit gate reductie op gestructureerde circuits: 100% voor QAOA en 87,8% voor QFT. In contrast hiermee behaalde Qiskit (L3) respectievelijk slechts 1,5% en 12,2%.
Misleidend Totaal Aantal Gates: Qiskit L2/L3 vertoonde een hoge totale gate reductie (47,7%), maar dit werd gedreven door single-qubit consolidatie ( $u_3$ ), wat resulteerde in slechts 9,3% two-qubit reductie.
Random Circuits: Voor ongestructureerde random circuits presteerde Qiskit-L3-IQM beter dan QCO (16,0% vs. 3,2% two-qubit reductie), wat de waarde van algemene optimalisatiestrategieën voor niet-gestructureerde workloads benadrukt.

Hardware Validatie

Model als Bovenlimiet: Het Lindblad model overschatte consistent de absolute fidelity op echte hardware met een gemiddelde van 0,49.
Behoud van Ordening: Ondanks de absolute offset behield het model correct de relatieve moeilijkheidsgraad van de circuits (bijv. ondiepe GHZ circuits behielden een hogere fidelity dan diepe QFT circuits).
Foutenbudget: De kloof kwantificeert niet-gemodelleerde foutbronnen, waaronder crosstalk, leakage, en readout/SPAM errors.

Betekenis en Claims

Het artikel claimt concreet advies te bieden voor quantum compiler design in het NISQ-tijdperk door de kloof te overbruggen tussen abstracte gate optimalisatie en fysieke pulse-niveau fidelity.

Praktische Begeleiding: De auteurs concluderen dat compiler designers prioriteit moeten geven aan gate cancellation (die bijna de volledige optimalisatie waarde draagt), twee-qubit gate counts moeten rapporteren in plaats van totale gate counts, en over-engineering van pass ordering moeten vermijden.
Domein Specifiteit: De resultaten suggereren dat productierecompilers zowel algemene passes (effectief voor random circuits) als domein-specifieke strategieën (essentieel voor gestructureerde algoritmen zoals QFT en QAOA) moeten bevatten.
Model Beperkingen: De auteurs geven expliciet aan dat hun model een schaalbare benadering is die inter-gate correlaties en crosstalk weglaat. De hardware benchmark dient om deze "optimisme kloof" te kwantificeren in plaats van de absolute fidelity waarden te valideren.
Toekomstig Werk: Het paper merkt op dat het vaststellen van optimalisatie verbeteringen op hardware met voldoende statistische kracht toekomstig werk vereist met meer shots en repetities, en dat het uitbreiden van het framework naar aanvullende apparaten en ongestructureerde circuit optimizers een logische volgende stap is.

Het werk wordt als open-source vrijgegeven om reproduceerbare quantum compilatie benchmarking te faciliteren.