⚛️ quantum physics

From Circuits to Hardware: Benchmarking Standard and Qubit-Efficient Quantum Optimization on Real Hardware

Dit artikel presenteert een uitgebreide benchmark op echte hardware van diverse gate-gebaseerde kwantumoptimalisatie-algoritmen voor vier NP-harde problemen op IBM Heron-processors, waarbij wordt onthuld dat de huidige ruisniveaus de meeste haalbare uitkomsten ononderscheidbaar maken van willekeurige kans en dat hoewel qubit-efficiënte methoden de uitvoerbare instantiegrootte vergroten, deze nog steeds beperkt worden door een strikt empirisch fideliteitsbudget.

Oorspronkelijke auteurs: Monit Sharma, Hoong Chuin Lau

Gepubliceerd 2026-07-14

📖 8 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Monit Sharma, Hoong Chuin Lau

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 enorme, verstrengelde puzzel probeert op te lossen met een gloednieuwe, super breekbare robotarm. Je hebt een hele reeks verschillende strategieën: sommige proberen de hele puzzel in één keer te grijpen, andere proberen de puzzel kleiner te maken zodat hij in je broekzak past, en weer anderen proberen de stukjes te herschikken voordat je überhaupt begint. Dit artikel is als een gigantische, echte stresstest van die robotarmen op vier heel verschillende soorten puzzels, gebruikmakend van echte kwantumcomputers (de "robotarmen") in plaats van alleen maar te doen alsof op een computerscherm.

Hier is het verhaal van wat er gebeurde toen ze deze strategieën aan de test legden op echte hardware.

Het Grote Plaatje: De "Broekzak-Puzzel" Valstrik

De belangrijkste bevinding is een beetje een realiteitscheck. Een tijdlang dachten mensen dat de beste manier om moeilijke problemen op kwantumcomputers op te lossen, was door het probleem kleiner te maken zodat het op minder "qubits" (de vingers van de robot) past. Het idee was: Minder vingers = makkelijker op te lossen.

Maar dit artikel suggereert dat dit niet altijd waar is. Hoewel het verkleinen van de puzzel (met "qubit-efficiënte" methoden) je wel in staat stelt om grotere problemen op de machine te passen, garandeert het niet dat je een goed antwoord krijgt. Sterker nog, soms maakt het verkleinen van de puzzel de robotarm zo wankel dat hij de stukjes volledig laat vallen. De auteurs hebben dit gemeten op echte IBM Heron-processors en ontdekten dat alleen omdat een methode minder qubits gebruikt, betekent niet dat deze ook beter werkt. Het is alsof je een zware doos probeert te dragen in een pieklein rugzakje; het rugzakje is weliswaar klein, maar als de doos te zwaar is voor je rug, laat je hem alsnog vallen.

De Vier Puzzels: Een Verhaal van Vier Problemen

De onderzoekers testten vier verschillende soorten "NP-harde" problemen (wat simpelweg betekent dat ze ook voor normale computers super moeilijk zijn). Elk probleem gedroeg zich anders:

Het Multi-Dimensionale Knapzakprobleem (MDKP): Stel je een rugzakreis voor waarbij je items moet inpakken die zwaar zijn, ruimte innemen en in specifieke vakken moeten passen.
- Wat er gebeurde: Dit was het "gulden middenمو". Alle methoden, van de grote tot de piekleine gecomprimeerde, slaagden er daadwerkelijk in om sommige geldige oplossingen te vinden. De gecomprimeerde methoden (PCE en QRAO) werkten goed bij dit probleem, wat bewijst dat het verkleinen van het probleem kan helpen, maar alleen als de robotarm stabiel genoeg is.
De Maximale Onafhankelijke Set (MIS): Stel je een feestje voor waarbij je zoveel mogelijk gasten wilt uitnodigen, maar waarbij geen twee gasten vijanden mogen zijn (ze kunnen niet naast elkaar zitten).
- Wat er gebeurde: Dit was de "klif". Voor kleine feestjes deden de robots het geweldig. Maar naarmate de feestjes groter werden, stopten de robots plotseling met werken. Het artikel laat een scherpe "haalbaarheidsklif" zien waarbij, zodra het feestje iets te groot wordt, de ruis op de echte hardware het onmogelijk maakt om enkele geldige gastenlijst te vinden. Het is alsof je een kaartenhuis probeert te balanceren in een orkaan; het werkt voor een paar kaarten, maar dan... poef, alles stort in.
Het Kwadratische Toewijzingsprobleem (QAP): Stel je voor dat je 10 of 12 mensen toewijst aan 10 of 12 bureaus, waarbij de kosten afhangen van hoe ver ze uit elkaar zitten en met wie ze praten.
- Wat er gebeurde: Dit was het "totale falen". Het artikel stelt expliciet dat geen enkele geteste methode een enkele geldige oplossing heeft geretourneerd voor dit probleem op echte hardware. Waarom? Omdat de regels zo strikt zijn (zoals een specifieke permutatie) dat de geldige antwoorden ongelooflijk zeldzaam zijn—slechts ongeveer 1 op $10^{23}$ tot $10^{34}$ mogelijke arrangementen zijn correct. De ruis op de computer heeft het signaal zo compleet overstemd dat de robots gewoon willekeurig aan het gokken waren. De auteurs betogen dat dit niet alleen een kwestie is van "we hebben betere computers nodig"; de structuur van het probleem zelf is te dicht voor de huidige technologie.
Het Marktaandeelprobleem (MSP): Stel je voor dat je een pizza probeert te verdelen zodat iedereen precies de stukjes krijgt die hij besteld heeft.
- Wat er gebeurde: Dit was de "compressieparadox". De gecomprimeerde methoden (Pั้งE en QRAO) maakten het probleem kleiner tot slechts 7–11 qubits (pieklein!), terwijl de normale methoden tot wel 156 qubits nodig hadden. Maar hier komt de crux: de piekleine methoden gaven verschrikkelijke resultaten. Ze konden de doelstellingen niet evenaren. De normale, grotere methoden deden het eigenlijk beter. Dit bewijst dat het kleiner maken van het probleem niet automatisch zorgt voor een beter antwoord.

De "Ruis"-factor: Wanneer de Robot Wankelt

Het artikel introduceert een coole manier om te meten hoeveel de computer wankelt. Ze noemen het een "fidelity proxy" ( $F_{est}$ ). Zie dit als een "signaal-ruisverhouding"-meter.

Als de meter hoog is (rond de 0,1 of 10%), is de robot stabiel genoeg om de instructies te horen.
Als de meter onder de 0,001 (0,1%) zakt, is de robot zo wankel dat hij eigenlijk alleen maar met zijn wielen aan het draaien is.

Ze ontdekten dat voor veel "QAOA"-stijl methoden (een populaire algoritmefamilie), de robot zo wankel was dat de resultaten niet te onderscheiden waren van het simpelweg kiezen van een willekeurig antwoord. Het artikel heeft een controletest uitgevoerd waarbij ze de output van de robot vergeleken met een uniforme willekeurige gok. Voor de meeste grote, complexe circuits deed de robot niet beter dan een willekeurige gok. Sterker nog, voor één specifere casus deed een "warm-start" methode het iets beter dan willekeurig, maar dat was een zeldzame uitzondering, geen regel.

Wat het Papier Uitsluit

De auteurs zijn zeer voorzichtig in wat ze niet hebben gevonden:

Ze sluiten de gedachte uit dat "minder qubits = betere prestaties". De data laten zien dat het verkleinen van de circuits vaak andere problemen introduceert (zoals diepere circuits na vertaling) die de voordelen tenietdoen.
Ze sluiten de gedachte uit dat QAOA-methoden momenteel klaar zijn voor gebruik op deze moeilijke problemen. Nadat de computer de instructies naar zijn eigen taal vertaalt (transpilatie), worden de circuits zo groot en luidruchtig dat ze falen. Zelfs als ze de routing (hoe de robot zijn vingers beweegt) zouden optimaliseren, zouden de circuits nog steeds te wankel zijn om te werken.
Ze sluiten de gedachte uit dat simulatie-resultaten (het doen alsof op een perfecte computer) het hele verhaal vertellen. De kloof tussen de "perfecte simulatie" en de "echte hardware" is enorm. Een methode die er geweldig uitziet in een simulatie, faalt vaak rampzalig op echte hardware vanwege de extra stappen die nodig zijn om het te laten werken.

Hoe Zeker Zijn Ze?

De auteurs zijn zeer zeker over wat ze hebben gemeten. Ze hebben niet zomaar gegokt; ze hebben 247 verschillende combinaties van methoden en problemen getest op echte IBM Heron-processors (specifiek de r1 en r2 versies). Ze hebben elke stap gelogd, van hoe de code is vertaald tot het uiteindelijke resultaat.

Ze hebben het exacte aantal gates (stappen) gemeten dat de robot moest nemen.
Ze hebben de foutpercentages van de specifieke chips die ze gebruikten gemeten.
Ze hebben delen gesimuleerd om een basislijn te krijgen, maar ze zijn duidelijk dat de simulatie-resultaten slechts een referentie zijn, niet het definitieve antwoord.

Ze beweren niet dat kwantumcomputers nutteloos zijn. Ze zeggen dat voor deze specifieke problemen en deze specifieke huidige machines, de "maak het kleiner" strategie grenzen heeft, en dat sommige problemen (zoals QAP) op dit moment gewoon te moeilijk zijn. Ze suggereren dat we naar het hele plaatje moeten kijken — de grootte van het probleem, de ruis en hoe de code wordt vertaald — in plaats van alleen maar het aantal qubits te tellen.

De Takeaway voor een Nieuwsgierige Tiener

Denk aan kwantumoptimalisatie als het proberen te sturen van een bericht door een lawaaierige kamer.

De "Standaard" manier is om de hele boodschap duidelijk te schreeuwen. Het is luid, maar als de kamer te groot is, wordt de boodschap overstemd door het lawaai.
De "Gecomprimeerde" manier is om een gecodeerde boodschap te fluisteren. Het is stiller en past in een kleinere ruimte, maar als de code te complex is of de kamer te luidruchtig, kan niemand de code ontcijferen en krijg je alleen maar onzin.

Dit artikel zegt: "Hé, fluisteren is niet altijd het antwoord! Soms is de ruis in de kamer zo erg dat zelfs de beste code verloren gaat. En voor sommige echt lastige puzzels (zoals de QAP), is de kamer gewoon te luidruchtig voor al onze huidige robots om ze op te lossen."

De auteurs zeggen niet: "Geef het op." Ze zeggen: "Laten we stoppen met doen alsof we het probleem hebben opgelost, alleen maar omdat we de puzzel kleiner hebben gemaakt. We moeten naar de hele puinhoop kijken — de ruis, de vertaling en het werkelijke resultaat — om te zien wat er echt werkt."

Titel: Van Circuits naar Hardware: Benchmarking van Standaard en Qubit-efficiënte Kwantumoptimalisatie op Realistische Hardware

Auteurs: Monit Sharma en Hoong Chuin Lau
Publicatie: IOP Publishing (Journal of Quantum Science and Technology, in wording)

Probleemstelling

Ondanks de snelle vooruitgang in kwantumoptimalisatie-algoritmen, ontbreekt het het vakgebied aan brede benchmarks op echte hardware die meerdere algoritmische families vergelijken over diverse, klassiek harde combinatorische problemen onder een uniform protocol. Bestaande evaluaties zijn vaak beperkt tot enkelvoudige probleemklassen, enkelvoudige algoritmefamilies, of simulator-gebaseerde instellingen die er niet in slagen om praktische beperkingen zoals compilatie-overhead, qubit-connectiviteit, gate-ruis en executievariabiliteit mee te nemen. Bijgevolg blijft het moeilijk om te beoordelen hoe verschillende strategieën (standaard variatieve methoden versus qubit-efficiënte encodings) zich verhouden wanneer ze naar echte apparaten worden gemapt, of om te bepalen wanneer qubit-efficiënte formuleringen werkelijke praktische voordelen bieden die verder gaan dan nominale breedtevermindering.

Methodologie

De auteurs presenteren een hardware-bewuste benchmarkingstudie uitgevoerd op IBM Heron r1 en r2 processors (supergeleidende transmon-devices) onder resilience-level-2 mitigatie. De studie evalueert gate-gebaseerde kwantumoptimalisatiemethoden over vier NP-harde combinatorische probleemklassen:

Multi-Dimensional Knapsack Problem (MDKP): Verpakkingsachtige beperkingen.
Maximum Independent Set (MIS): Grafentheoretische onafhankelijkheidsstructuur.
Quadratic Assignment Problem (QAP): Dichte, sterk gekoppelde kwadratische toewijzing.
Market Share Problem (MSP): Applicatie-gedreven evenwichtbeperkingen.

Geteste Algoritmische Families:

Variatieve Energie-minimalisatie: Variational Quantum Eigensolver (VQE) en Conditional Value-at-Risk VQE (CVaR-VQE).
QAOA-stijl: Standaard QAOA, Warm-Start QAOA (WS-QAOA) en Multi-Angle QAOA (MA-QAOA).
Qubit-efficiënte Encodings: Pauli Correlation Encoding (PCE) en Quantum Random Access Optimization (QRAO).

Experimenteel Protocol:

Workflow: Alle problemen werden omgezet naar Quadratic Unconstrained Binary Optimization (QUBO) vorm met behulp van kwadratische strafleden, waarna ze werden gemapt naar Ising-Hamiltonianen.
Executie: De studie maakte gebruik van een fixed-shot variatief optimalisatieprotocol (COBYLA optimizer, 200 iteraties, 1.000 shots per evaluatie) op echte hardware.
Metrieken: De benchmark rapporteert oplossingskwaliteit (optimaliteitskloof of doelafwijking), haalbaarheid, algoritme-niveau circuitbreedte, getranspileerde circuitdiepte, twee-qubit gate-aantallen ( $N_{2Q}$ ), compilatie-overhead en executie-robuustheid.
Fidelity Modellering: Een onafhankelijke error gate-count fidelity proxy ( $F_{est} \approx (1 - \epsilon_{2Q})^{N_{2Q}}$ ) werd afgeleid van backend-kalibratiedata om onderscheid te maken tussen signaal-behoudende en ruis-gedomineerde executie-regimes.

Belangrijkste Bijdragen

Uniforme Cross-Family Benchmark: De eerste uniforme benchmark die variatieve, QAOA-stijl en qubit-efficiënte methoden evalueert over vier structureel verschillende NP-harde problemen onder een gemeenschappelijk experimenteel protocol.
Hardware-bewuste Evaluatie: Een verschuiving van geïdealiseerde resource-schattingen naar een protocol dat compilatie-overhead, getranspileerde circuitkenmerken en executie-robuustheid als primaire benchmark-dimensies behandelt.
Kwantitatieve Ruisdrempels: De vaststelling van een empirisch gegronde fidelity-drempel ( $F_{est} \approx 0,1$ , overeenkomend met $\sim770$ twee-qubit gates op Heron-r2) die de overgang markeert naar een door ruis gedomineerd executie-regime.
Reproduceerbare Baseline: Een volledig reproduceerbare empirische baseline inclusief softwarestacks, backend-metadata, transpilation-policies en per-instance diagnostiek, waarbij alle code en instanties publiekelijk beschikbaar zijn.

Belangrijkste Resultaten

MDKP (Gebalanceerd Regime): Alle methodenfamilies leverden haalbare oplossingen. Qubit-efficiënte methoden (Pente, QRAO) verminderden de qubit-vereisten aanzienlijk, maar presteerden niet uniform beter dan full-width methoden wat betreft oplossingskwaliteit. CVaR-VQE vertoonde sterke prestaties op specifieke instanties.
MIS (Feasibility Cliff): Er werd een scherpe doorbraak in haalbaarheid waargenomen naarmate de instantiegrootte toenam. Terwijl kleine instanties werden opgelost met een nul-kloof, zag men bij grotere instanties (64+ qubits) een instorting van de haalbaarheid voor de meeste methoden, waarbij alleen Warm-Start QAOA haalbaar bleef op de grootste geteste graaf.
QAP (Structurele Barrière): Geen van de geteste hardware-methoden leverde een haalbare toewijzing voor enig QAP-instantie. De combinatie van dichte interacties, strikte one-hot beperkingen en een exponentieel ijl haalbaar manifold ( $10!/2^{100} \approx 10^{-23,54}$ ) maakte alle geteste pipelines onhaalbaar op de huidige hardware, zelfs voor de kleinste instanties.
MSP (Compressie versus Kwaliteit): Qubit-efficiënte encodings bereikten een dramatische breedtevermindering (7–11 qubits versus 48–156), maar resulteerden in aanzienlijk slechtere herstelde oplossingskwaliteit (grote doelafwijkingen) vergeleken met full-width methoden.
Compilatie-overhead: Transpilatie verhoogde de twee-qubit gate-aantallen met factoren van 4,5 tot 6,2 over de verschillende probleemfamilies. Voor QAOA-familie circuits overschreden de getranspileerde twee-qubit aantallen vaak de 20.000, waardoor $F_{est}$ onder $10^{-30}$ zakte.
Ruis-dominantie: Een gematchte uniform-random controle toonde aan dat voor laag-fidelity QAOA-familie runs ( $F_{est} < 10^{-3}$ ), de meeste haalbare uitkomsten binnen het empirische willekeurige bereik lagen, wat suggereert dat het signaal werd gedomineerd door ruis.
Simulator-Hardware Gat: Simulator-ranglijsten werden niet uniform overgedragen naar hardware. In sommige MDKP-gevallen bereikten hardware-runs lagere kloven dan simulators (mogelijk door finite-shot stochasticity), terwijl in andere gevallen de hardwareprestaties aanzienlijk verslechterden.

Betekenis en Claims

Het artikel maakt geen aanspraak op een praktisch kwantumvoordeel ten opzichte van klassieke solvers. In plaats daarvan vestigt het een systematische empirische baseline voor het beoordelen van kwantumoptimalisatie onder realistische beperkingen.

Qubit-aantal is Onvoldoende: De studie demonstreert dat een lager aantal qubits (via compressie) niet consistent een betere uiteindelijke prestatie op hardware impliceert. Winsten uit breedtevermindering worden vaak gecompenseerd door transpilation-overhead, verhoogde effectieve circuitdiepte of verminderde robuustheid.
Probleem-afhankelijke Levensvatbaarheid: Praktische prestaties zijn sterk afhankelijk van de interactie tussen probleemstructuur, encoding-keuze en hardware-beperkingen. Een methode die competitief is op één probleemklasse (bijv. MDKP), kan volledig falen op een andere (bijv. QAP).
Compilatie als een Primaire Metriek: De identiteit van een kwantumoptimalisatiemethode verandert materieel na transpilatie. Benchmarks moeten getranspileerde circuitkenmerken (diepte, $N_{2Q}$ ) rapporteren in plaats van alleen algoritme-niveau breedte om een volledig beeld te geven van inzetbaarheid.
Fidelity Drempels: De afgeleide $F_{est}$ drempels bieden bruikbare richtlijnen, waarbij zij aangeven dat de huidige hardware waarschijnlijk door ruis wordt gedomineerd voor diepe QAOA-circuits en dichte toewijzingsproblemen, wat het regime beperkt waarin kwantummethoden betrouwbaar kunnen worden getest.

De auteurs concluderen dat nabije-toekomst benchmarking zich moet richten op het karakteriseren van trade-offs (breedte versus kwaliteit, algoritmisch ontwerp versus gecompileerde kosten) in plaats van het zoeken naar één "beste" algoritme, en dat claims van praktisch voordeel ondersteund moeten worden door hardware-gerealiseerde oplossingskwaliteit en executie-diagnostiek, en niet alleen door simulatorresultaten of nominale qubit-aantallen.