Large-Scale Quantum Circuit Simulation on an Exascale System for QPU Benchmarking

Deze studie toetst de 98-qubit Quantinuum Helios-1-quantumprocessor door de experimentele output te vergelijken met grootschalige ruisvrije simulaties op Europa's exascale-supercomputer JUPITER, en onthult dat het apparaat coherente prestaties behoudt tot 93 qubits, waarna de resultaten statistisch niet meer te onderscheiden zijn van willekeurige steekproeven.

De kern

Stel je voor dat je een gloednieuw, ongelooflijk complex muzikaal instrument (een kwantumcomputer) hebt dat noten kan spelen die nog nooit door een mens zijn gehoord. Maar er is een probleem: het instrument is een beetje "ruisend". Soms speelt het, in plaats van de perfecte noot die je hebt gevraagd, een lichtjes vals geluid of een willekeurige zoem. De grote vraag is: Op welk moment wordt de muziek zo ruisend dat het gewoon willekeurige statische ruis is, en wanneer is het nog steeds een mooi, betekenisvol lied?

Dit artikel gaat over het vinden van het antwoord op die vraag voor een specifiek instrument genaamd Helios-1, dat 98 "toetsen" (qubits) heeft. De onderzoekers gebruikten een enorme, supersnelle klassieke computer (een supercomputer genaamd JUPITER) om te fungeren als een "perfecte referentie" om te zien hoe goed het ruisende instrument eigenlijk presteert.

Hier is de uiteenzetting van hun reis:

1. De Uitdaging: Signaal onderscheiden van Ruis

Stel je de kwantumcomputer voor als een kok die probeert een perfecte taart te bakken.

• Het Ideaal: Een perfecte taart (de ruisvrije simulatie).
• De Realiteit: De kok werkt in een windige keuken (ruis). Soms waait de wind het meel weg, of fluctueert de oventemperatuur.
• Het Doel: De onderzoekers wilden weten: "Is de taart die we krijgen nog steeds een echte taart, of heeft de wind het zo verpest dat het gewoon een kom met willekeurig meel en eieren is?"

Om dit te testen, gebruikten ze een specifiek recept genaamd LR-QAOA. Denk aan dit recept als een gestandaardiseerde "smaaktest" die steeds moeilijker wordt naarmate je meer ingrediënten (qubits) toevoegt.

2. De Super-Referentie: JUPITER

Om te weten hoe een "perfecte taart" eruitziet, heb je een referentie nodig. Voor kleine taarten (tot 48 ingrediënten) gebruikten de onderzoekers JUPITER, Europa's eerste "exascale" supercomputer.

• De Analogie: Stel je voor dat JUPITER een team is van 16.384 super-bakkers die perfect synchroon werken. Ze bakten de "perfecte taart" (een ruisvrije simulatie) op een computer.
• De Schaal: Dit was een enorme taak. Ze gebruikten 4.096 enorme computernodes om een 48-qubit circuit te simuleren. Dit is als proberen een storm in een fles te simuleren; het vereist een enorme hoeveelheid rekenkracht.
• Het Resultaat: Ze bakten succesvol de perfecte referentietarten voor maten tot 48 qubits.

3. Het Experiment: Helios-1 Testen

Nu vergeleken ze de echte Helios-1 kwantumcomputer met deze perfecte referenties.

• Tot 48 Qubits: Ze vergeleken de Helios-1-output direct met de JUPITER-simulatie. Het resultaat? De Helios-1-taart was zo dicht bij de perfecte referentie dat je het verschil niet kon zien. De "wind" (ruis) was er wel, maar het verpestte het recept nog niet. De machine bevond zich in een "ruis-tolerant" gebied.
• Boven de 48 Qubits: Hier wordt het lastig. Zodra je voorbij 48 qubits gaat, kan zelfs de supercomputer JUPITER de "perfecte taart" niet meer bakken omdat deze te groot is om te simuleren. De referentie verdwijnt.
• De Nieuwe Strategie: Omdat ze het niet konden vergelijken met een perfecte taart, vergeleken ze het met een willekeurige gok. Stel je voor dat je iemand vraagt de ingrediënten van een taart te raden door pijltjes op een bord te gooien.
  • Ze gebruikten een statistische truc (een "3-sigma" test) om te zien of de Helios-1-output beter was dan gewoon pijltjes gooien.
  • De Bevinding: Zelfs zonder een perfecte referentie ontdekten ze dat Helios-1 nog steeds een "echte taart" bakte (betekenisvolle resultaten produceerde) tot 93 qubits.
  • Het Breekpunt: Bij 95 qubits zag de output er eindelijk precies uit als het willekeurige pijltjesgooien. De ruis had de overhand genomen en het signaal was verloren.

4. Het "Low-Shot" Geheim

Een van de slimme trucs in dit artikel is hoe ze de machine testten. Meestal moet je een test 100 keer uitvoeren om een goed gemiddelde te krijgen.

• De Analogie: Stel je voor dat je soep proeft. Je zou 100 lepels kunnen nemen om zeker te zijn dat het zout is, of je zou slechts 10 lepels kunnen nemen als je een zeer zelfverzekerde kok bent.
• Het Resultaat: De onderzoekers toonden aan dat ze met hun specifieke statistische methode slechts 10 "shots" (proeven) nodig hadden om met vertrouwen te zeggen: "Ja, dit is een echte taart, geen willekeurige ruis." Dit bespaart een enorme hoeveelheid tijd en geld, aangezien het draaien van kwantumcomputers duur is.

5. De Hardware Showdown

Het artikel vergeleek ook de snelheid van verschillende computerchips die werden gebruikt voor de simulaties.

• De Race: Ze vergeleken de oudere A100 chips met de nieuwere H100 chips.
• Het Resultaat: De nieuwe H100 chips waren bijna twee keer zo snel. Het is als upgraden van een fiets naar een sportauto; je kunt op dezelfde bestemming komen in de helft van de tijd, of in dit geval, het probleem oplossen met de helft van het aantal computers.

De Conclusie

Dit artikel is een "stress-test" voor een kwantumcomputer.

1. Ze gebruikten een enorme supercomputer om te bewijzen dat de Helios-1 kwantumprocessor perfect goed werkt (is "ruis-tolerant") voor problemen tot 48 qubits.
2. Ze gebruikten statistische trucs om te bewijzen dat zelfs zonder een supercomputer-referentie, de machine nog steeds betekenisvolle resultaten produceert tot 93 qubits.
3. Bij 95 qubits stuit de machine uiteindelijk op een muur waar de ruis de resultaten ononderscheidbaar maakt van willekeurig gissen.

Kortom, ze vonden het exacte "kruispunt" waar de kwantumcomputer stopt met het zijn van een nuttig hulpmiddel en begint te worden als een bron van willekeurige ruis, terwijl ze tegelijkertijd bewezen dat we deze machines efficiënt kunnen testen zonder miljoenen monsters nodig te hebben.

Technische samenvatting

1. Probleemstelling

De snelle vooruitgang in kwantumcomputing heeft geleid tot processoren met honderden qubits (bijvoorbeeld Quantinuum's Helios-1 met 98 qubits). Echter, ruis en hardware-onvolkomenheden beperken de betrouwbaarheid van deze systemen ernstig. Een kritieke uitdaging is het identificeren van de grens tussen regimes waar kwantumprocessoren coherent, algoritmisch betekenisvol gedrag vertonen, en regimes waar ruis de uitkomsten effectief willekeurig maakt.

Bestaande benchmarkmethoden (zoals Quantum Volume en Cross-Entropy Benchmarking) vertrouwen vaak op klassieke simulatie van ideale verdelingen, wat onuitvoerbaar wordt boven ongeveer 50 qubits, of ze evalueren losstaande secties van een chip, waardoor geen holistisch beeld van systeemprestaties wordt geboden. Er is behoefte aan een schaalbaar, applicatieniveau-benchmark dat kwantumprocessoren kan valideren aan de rand van klassieke uitvoerbaarheid en daarbuiten.

2. Methodologie

De auteurs hanteren een veelzijdige aanpak die grootschalige klassieke simulatie combineert met experimentele kwantumuitvoering:

• Benchmarkprotocol (LR-QAOA):

  • De studie maakt gebruik van het Linear Ramp Quantum Approximate Optimization Algorithm (LR-QAOA) toegepast op volledig verbonden Weighted Max-Cut (WMC) problemen.
  • In tegenstelling tot variational QAOA gebruikt LR-QAOA een deterministische, niet-variational lineaire annealing-schedule, waardoor de noodzaak voor klassieke optimalisatielussen wordt verwijderd. Dit isoleert de intrinsieke hardwareprestaties van algoritmische afstemming.
  • Maatstaf: De Benaderingsratio ($r$) wordt gebruikt om de prestaties te meten. Deze vergelijkt de gemiddelde kosten van steekproeven verkregen van de Quantum Processing Unit (QPU) met de optimale oplossing en een willekeurige steekproef-basislijn.

• Statistisch Classificatiekader:

  • Om het beperkte aantal shots (steekproeven) te hanteren dat beschikbaar is op dure QPUs, ontwikkelden de auteurs een "mean-of-means" resampling-procedure.
  • Zij construeren Kernel Density Estimates (KDE's) van de gemiddelde benaderingsratio uit referentieverdelingen (ruisvrije simulatie en willekeurige steekproeven).
  • Regime-classificatie:
    • Ruis-tolerant: QPU $r$ valt binnen het 99,73% betrouwbaarheidsinterval ($3\sigma$) van de ruisvrije simulatie.
    • Overgang: QPU $r$ ligt tussen de ruisvrije en willekeurige intervallen.
    • Willekeurig: QPU $r$ is statistisch niet te onderscheiden van willekeurige steekproeven (onder de willekeurige $3\sigma$-drempel).
  • Deze methode maakt een statistisch significante classificatie mogelijk met slechts 10 shots.

• Klassieke Simulatie-infrastructuur (JUPITER):

  • Simulaties werden uitgevoerd op JUPITER, Europa's eerste exascale supercomputer, met behulp van de JUQCS-simulator.
  • Hardware: Tot 4.096 nodes uitgerust met 16.384 NVIDIA Grace Hopper GH200 superchips (totaal 16.384 GPU's).
  • Schaal: Ruisvrije state-vector-simulaties werden uitgevoerd voor circuits tot 48 qubits (3.384 twee-qubit-poorten) met FP32-precisie.
  • Geheugenstrategie: Voor 48 qubits gebruikte de simulatie zowel apparaat- (96 GiB) als host-geheugen (120 GiB) per superchip, waarbij 16.384 chips nodig waren om de $2^{48}$ complexe amplitude op te slaan.

• Experimentele Opstelling:

  • Apparaat: Quantinuum Helios-1, een 98-qubit gevangen-ion QPU gebaseerd op een Quantum Charge-Coupled Device (QCCD)-architectuur met all-to-all connectiviteit.
  • Scope: Experimenten werden uitgevoerd op volledig verbonden WMC-instanties voor qubit-aantallen variërend van 40 tot 98.
  • Beperkingen: Vanwege de kwadratische schaling van Hardware Quantum Credits (HQC) met het qubit-aantal, waren experimenten beperkt tot lage shot-aantallen (9–49 shots) om binnen het budget te blijven.

3. Belangrijkste Bijdragen

1. Eerste Exascale QPU Benchmarking-simulatie: De auteurs voerden de tot nu toe grootste gerapporteerde QAOA-simulatie uit met FP32-precisie, waarbij een 48-qubit circuit werd gesimuleerd op 4.096 nodes van de JUPITER-supercomputer.
2. Identificatie van de Coherentiegrens: Zij vestigden een kwantitatieve grens voor Helios-1, waarbij ruis-tolerante werking tot 48 qubits werd gecertificeerd (via simulatie) en coherent prestatievermogen tot 93 qubits (via experimentele extrapolatie).
3. Statistische Methodologie met Lage Shots: Er werd een robuuste statistische test geïntroduceerd met behulp van mean-of-means resampling en een $3\sigma$-drempel, waardoor betrouwbare prestatieclassificatie mogelijk is met minimale steekproeven (zoveel als 10 shots).
4. Cross-platform GPU-benchmarking: Aangetoond dat NVIDIA H100 GPU's (JUPITER) een 1,9× snelheidswinst behalen ten opzichte van A100 GPU's (JUWELS Booster) voor 30-qubit simulaties, en de uitvoeringstijd van een 40-qubit simulatie bereikten met de helft van het aantal GPU's.

4. Belangrijkste Resultaten

• Simulatieprestaties:

  • Sterke schalingstests op JUPITER toonden een bijna ideale snelheidswinst (3,7×) bij het verhogen van GPU's van 128 naar 512 voor een 40-qubit probleem.
  • Bij 48 qubits duurde de simulatie ongeveer 2.490 seconden, wat de aanzienlijke overhead van host-apparaat gegevensoverdrachten en MPI-communicatie benadrukt bij gebruik van gecombineerd geheugen.
  • H100 GPU's presteerden aanzienlijk beter dan A100's, met name bij diepere circuits ($p=100$).

• Helios-1 Benchmarkresultaten:

  • 40–48 Qubits (Ruis-tolerant Regime): Helios-1-steekproeven waren statistisch niet te onderscheiden van de ruisvrije JUPITER-simulatie en duidelijk gescheiden van willekeurige steekproeven. Dit bevestigt dat het apparaat opereert in een ruis-tolerant regime waar de geaccumuleerde ruis verwaarloosbaar is ten opzichte van het algoritmische signaal.
  • 49–93 Qubits (Overgang/Coherent Regime): Voor maten buiten klassieke verificatie behield de QPU een statistisch significante scheiding van willekeurige steekproeven tot 93 qubits (12.834 twee-qubit-poorten).
  • 95–98 Qubits (Willekeurig Regime): Bij 95 en 98 qubits vielen de uitkomsten onder de $3\sigma$ willekeurige drempel, waardoor ze statistisch niet te onderscheiden waren van willekeurige steekproeven. Dit markeert de praktische limiet van de huidige apparaatcoherentie voor deze specifieke benchmark.

• Vergelijking met eerdere generaties:

  • Helios-1 bereikte benaderingsratio's die vergelijkbaar waren met of hoger waren dan de processor van de vorige generatie H2-1, ondanks het gebruik van aanzienlijk minder shots (10 versus 50), wat wijst op hardwareverbeteringen.

5. Betekenis

• Validatie aan de Rand van Uitvoerbaarheid: Het werk demonstreert hoe exascale klassieke computing kan dienen als een "gouden standaard" referentie om kwantumprocessoren te valideren tot aan de limiet van wat klassiek simuleerbaar is (48 qubits).
• Definiëren van de "Kwantumvoordeel"-grens: Door te identificeren dat Helios-1 coherent blijft tot 93 qubits voordat het degradeert naar willekeur, biedt de studie een concreet, kwantitatief criterium voor de operationele limieten van huidige gevangen-ion technologie.
• Schaalbaar Benchmarkkader: Het LR-QAOA-protocol biedt een platform-onafhankelijk, interpreteerbaar kader dat geen parameterafstemming of nabewerking vereist, waardoor het ideaal is voor het evalueren van kwantumapparaten op korte termijn naarmate ze schalen buiten klassieke verificatie.
• Inzichten in Hardware-efficiëntie: De studie benadrukt de efficiëntiewinsten van hardware van de volgende generatie (H100/Grace Hopper) zowel in klassieke simulatie als in het potentieel voor efficiënter kwantumresourcegebruik.

Concluderend overbrugt dit artikel de kloof tussen klassieke simulatie en experimentele kwantumcomputing, en biedt het een rigoureuze methodologie om onderscheid te maken tussen ware kwantumcoherentie en door ruis veroorzaakte willekeur in grootschalige kwantumprocessoren.