Universal Quantum Computer Simulation of 50 Qubits on Europe`s First Exascale Supercomputer Harnessing Its Heterogeneous CPU-GPU Architecture

Onderzoekers hebben voor het eerst een universele quantumcomputer van 50 qubits gesimuleerd op Europa's exascale-supercomputer JUPITER door gebruik te maken van zijn heterogene GH200-architectuur via drie sleutelinnovaties: uitgebreid geheugengebruik via CPU-GPU-verbindingen, adaptieve data-encoding en een netwerkverkeersoptimizer die in real-time werkt, waarmee een snelheidswinst van 16,6 keer ten opzichte van eerdere records werd bereikt.

De kern

Stel je voor dat je een puzzel probeert op te lossen waarbij elke keer als je één stukje toevoegt, het aantal mogelijke rangschikkingen van de hele puzzel verdubbelt. Als je 10 stukjes hebt, is dat nog te overzien. Maar als je 50 stukjes hebt, is het aantal mogelijkheden zo enorm dat het alle computers op aarde, gezamenlijk werkend, miljarden jaren zou kosten om ze allemaal te controleren. Dit is de uitdaging bij het simuleren van een quantumcomputer.

Dit artikel beschrijft hoe een team van wetenschappers van het Jülich Supercomputing Centre in Duitsland, in samenwerking met NVIDIA, een "super-simulator" bouwde genaamd JUQCS-50. Zij gebruikten de eerste "Exascale"-supercomputer van Europa (genaamd JUPITER) om voor het eerst een quantumcomputer met 50 qubits te simuleren.

Hieronder wordt uitgelegd hoe ze dit deden, via eenvoudige analogieën:

1. Het Probleem: De "Geheugengrens"

Om een quantumcomputer te simuleren, moet je een enorme lijst met getallen opslaan (een "state vector" genoemd) die elke mogelijke toestand van het systeem vertegenwoordigt.

• De Analogie: Stel je voor dat je probeert een bibliotheek met boeken op te slaan. Voor een kleine quantumcomputer (48 qubits) past de bibliotheek op een paar harde schijven. Maar voor een computer met 50 qubits is de bibliotheek zo groot dat hij een pakhuis ter grootte van een kleine stad zou vullen.
• De Limiet: De supercomputer die ze gebruikten (JUPITER) heeft extreem snel geheugen (zoals een hoogwaardige sportauto), maar zelfs dat was niet groot genoeg om de volledige bibliotheek van 50 qubits tegelijkertijd te bevatten.

2. De Oplossing: Drie "Tovenaarskunsten"

Om deze enorme bibliotheek in de beschikbare ruimte te passen en snel te laten draaien, gebruikte het team drie slimme trucs:

Truc #1: De "Gedeelde Rugzak" (Heterogeen Geheugen)

Normaal gesproken heeft een computer een kleine, supersnelle rugzak (GPU-geheugen) en een grotere, iets langzamere rugzak (CPU-geheugen). De oude aanpak was om alleen de snelle te gebruiken.

• De Innovatie: Het team besefte dat ze beide rugzakken als één grote, continue ruimte konden behandelen. Ze bouwden een supersnelle brug (NVLink genaamd) tussen de CPU en de GPU.
• Het Resultaat: Ze konden data opslaan in de grotere, langzamere rugzak wanneer nodig, maar het direct verplaatsen naar de snelle voor berekeningen. Het is alsof je een pakhuis naast je werkplaats hebt; je bewaart het grootste deel van je gereedschap in het pakhuis, maar een transportband brengt ze in een splitseconde naar je werkbank.

Truc #2: Het "Gecomprimeerde Zip-bestand" (Adaptieve Byte-codering)

Het opslaan van de getallen in hun volledige, hoge precisie-formaat (zoals een foto in hoge resolutie) neemt te veel ruimte in beslag.

• De Innovatie: Het team ontwikkelde een manier om de data te "zippen". Ze comprimeerden de getallen tot een kleinere grootte (zoals het omzetten van een foto in hoge resolutie naar een miniatuur) net genoeg om ze in het geheugen te passen, maar slim genoeg om ze bij het uitvoeren van de wiskunde direct weer "uit te zippen" naar volledige precisie.
• Het Resultaat: Dit verlaagde de benodigde geheugenruimte met 8 keer, waardoor ze de simulatie van 50 qubits in de beschikbare ruimte pasten zonder de nauwkeurigheid van het antwoord te verliezen.

Truc #3: De "Verkeersregelaar" (On-the-Fly Optimizer)

Wanneer je duizenden computers samenwerkt, moeten ze voortdurend met elkaar communiceren. Als ze allemaal tegelijk proberen te praten, raakt het netwerk verstopt (verkeersopstopping).

• De Innovatie: De software fungeert als een slimme verkeersregelaar. Hij kijkt naar de volgende stap van de puzzel en beslist precies wanneer en wat er verzonden moet worden, zodat de computers altijd aan het werk zijn terwijl de data op de achtergrond verplaatst wordt.
• Het Resultaat: Dit minimaliseerde de tijd die de computers besteedden aan wachten op elkaar, waardoor de simulatie soepel bleef draaien.

3. Het Resultaat: Een Rekordbrekende Run

Door deze trucs te combineren op de JUPITER-supercomputer (die 16.384 krachtige "superchips" gebruikt), bereikte het team iets dat nog nooit eerder is gedaan:

• Snelheid: Ze simuleerden de computer met 50 qubits 16,6 keer sneller dan het vorige wereldrecord, gehouden door een andere supercomputer (de K-computer).
• Efficiëntie: Waar de tijd om te simuleren doorgaans exponentieel explodeert naarmate je qubits toevoegt, slaagde hun systeem erin de tijd bijna lineair te laten groeien. Het is alsof ze een manier vonden om een auto te maken die sneller wordt naarmate er meer passagiers in zitten, in plaats van langzamer.

4. Waarom Dit Belangrijk Is (Volgens het Artikel)

Het artikel benadrukt dat dit een simulatie is, geen echte quantumcomputer.

• De "Perfecte" Lab: Echte quantumcomputers zijn tegenwoordig luidruchtig en maken fouten. Deze simulator biedt een "perfecte" versie van een quantumcomputer met 50 qubits.
• De Benchmark: Het stelt wetenschappers in staat om nieuwe quantumalgoritmen (zoals die voor chemie of optimalisatie) te testen en te zien wat het ideale resultaat zou moeten zijn. Dit helpt hen te begrijpen hoe ze de fouten in echte, fysieke quantummachines kunnen oplossen.
• De Toepassing: Het team testte dit specifiek op "adder circuits" (wiskundeproblemen) en ontdekte dat, zelfs met hun data-compressietruc, de wiskunde perfect correct uitkwam.

Samenvattend: Het team bouwde een digitale "tijdmachine" die een quantumcomputer met 50 qubits perfect kan simuleren. Ze deden dit door het geheugen van een enorme supercomputer slim uit te rekken en het dataverkeer zo efficiënt te organiseren dat ze de vorige snelheids- en groottereCORDS braken, waardoor wetenschappers een krachtig nieuw instrument kregen om toekomstige quantumtechnologieën te ontwerpen en te testen.

Technische samenvatting

Technische Samenvatting: Universele Simulatie van een Quantumcomputer met 50 Qubits op Europa's Eerste Exascale Supercomputer

Probleemstelling
Het simuleren van universele quantumcomputers op klassieke hardware is computationeel onuitvoerbaar vanwege de exponentiële groei van geheugen- en runtime-eisen in verhouding tot het aantal qubits ($N$). Het opslaan van de volledige toestandsvector voor een systeem van $N$ qubits in dubbele precisie (FP64) vereist $2^{N+4}$ bytes. Voor $N=50$ is dit ongeveer 16.384 TiB geheugen nodig, wat ver buiten de capaciteit van individuele versnellers ligt. Bovendien introduceert het verdelen van deze toestand over een cluster enorme communicatie-overschotten, met name voor poorten die op "niet-lokale" qubits werken (die waarvan de indexen de geheugencapaciteit van een enkele verwerkingseenheid overschrijden). Huidige quantumhardware wordt beperkt door ruis en poortonnauwkeurigheid, waardoor grootschalige, betrouwbare uitvoering onhaalbaar is; daarom blijft hoogwaardige klassieke simulatie essentieel voor algoritmeontwikkeling en benchmarking.

Methodologie en Innovaties
De auteurs presenteren JUQCS-50, een hoogpresterende universele quantumcomputersimulator ontworpen om gebruik te maken van de heterogene CPU-GPU-architectuur van de JUPITER-supercomputer (specifiek de NVIDIA GH200 superchips). Het systeem maakt gebruik van 16.384 GH200 superchips verspreid over 4.096 knooppunten. Om de geheugen- en communicatieflessenhals te overwinnen, implementeert JUQCS-50 drie primaire innovaties:

1. Heterogeen Geheugengebruik: De simulator breidt het bruikbare geheugen uit buiten de limieten van het High Bandwidth Memory (HBM3) van de GPU door het LPDDR5-geheugen van de CPU te integreren. Het ontwerp behandelt de CPU strikt als geheugenhuisvesting, terwijl alle berekeningen, codering en decodering op de GPU worden uitgevoerd. Om gegevensplaatsing efficiënt te beheren tussen HBM3 en LPDDR5, maken de auteurs gebruik van expliciete functies voor gegevensoverdracht in combinatie met een netwerkverkeersoptimizer die in real-time werkt. Deze aanpak maakt gebruik van CUDA-bewust MPI en asynchrone kopieerfuncties om prestatieverliezen geassocieerd met geheugenoverschrijding te minimaliseren.
2. Adaptieve Bytecodering: Om de geheugenbehoefte met een factor acht te verminderen, hanteert de simulator een adaptief byte-coderingsschema. Deze methode stelt complexe elementen van de toestandsvector voor met 2 bytes (16 bits) in plaats van de standaard 16 bytes (FP64). De codering is gebaseerd op de polaire representatie van complexe getallen en past zich aan aan de specifieke quantumcircuit die wordt uitgevoerd. Hoewel dit een rekenkundige overhead introduceert voor codering/decodering in real-time, vermindert het aanzienlijk het datavolume dat over het netwerk wordt overgedragen, wat de primaire bottleneck is voor grote $N$.
3. Communicatieoptimalisatie: Het systeem minimaliseert inter-knooppuntcommunicatie via standaard CUDA-bewuste MPI-aanroepen en asynchrone stream-functies voor het inpakken/uitpakken van gegevens. Bovendien tonen de auteurs aan dat strategische hernoeming van qubits het volume uitgewisselde gegevens tussen superchips aanzienlijk kan verminderen, met name voor specifieke circuittopologieën zoals adder-circuits.

Belangrijkste Resultaten
Het artikel rapporteert de eerste succesvolle simulatie van een universele quantumcomputer met 50 qubits met behulp van een toestandsvectorbenadering.

• Schaalbaarheid: De simulator toont een bijna lineaire schaalbaarheid in verstreken tijd bij toenemend aantal qubits (zwakke schaalbaarheid), waardoor de theoretische exponentiële tijdschaalbaarheid effectief wordt gemitigeerd door massale parallelisatie.
• Prestatievergelijking: JUQCS-50 bereikt een 16,6-voudige snelheidswinst ten opzichte van het vorige record van 48 qubits, gehouden door de K-computer. Voor een 36-qubit Hadamard-benchmark daalde de verstreken tijd per poort van 47,03 seconden op de K-computer naar 2,83 seconden op JUPITER.
• Precisie en Afwegingen: De studie valideert dat voor specifieke benchmarkcircuits (bijvoorbeeld sequenties van Hadamard-poorten) het byte-coderingsschema nauwkeurigheid op FP64-niveau behoudt. Echter, voor circuits die gecontroleerde faseverschuivingen omvatten (zoals gehele getallen-adders), worden kleine afwijkingen in verwachtingswaarden voor x- en y-componenten waargenomen, hoewel de primaire resultaten voor de z-component correct blijven.
• Netwerkefficiëntie: Voor het geval van 50 qubits traverseert ongeveer 38.766 TiB aan gegevens het netwerk tijdens de simulatieserie, voltooid in ongeveer 100 seconden. De gemeten bandbreedte schaalt als $O(1/\sqrt{N})$ vanwege netwerktopologiebeperkingen (Dragonfly+), waarbij de dominantie verschuift van intra-knooppunt NVLink naar inter-knooppunt InfiniBand naarmate het aantal qubits toeneemt.

Betekenis en Beweringen
Het artikel beweert dat JUQCS-50 de simulatie van quantumcircuits met tot 50 qubits mogelijk maakt, een schaal die het betrouwbare werkingsregime van huidige quantumprocessors (die lijden onder ruis en beperkte diepte) overstijgt. Door bijna lineaire tijdschaalbaarheid te bereiken, maakt de simulator nauwkeurige benchmarking van algoritmen mogelijk, zoals de Variational Quantum Eigensolver (VQE) en de Quantum Approximate Optimization Algorithm (QAOA), op systemen die ver groter zijn dan die momenteel realiseerbaar zijn op fysieke hardware.

De auteurs benadrukken dat hoewel gespecialiseerde simulators (bijvoorbeeld tensornetwerken of circuit-snijtechnieken) grotere aantallen qubits kunnen verwerken voor specifieke, gestructureerde circuits, JUQCS-50 een universele simulator is die willekeurige circuits kan uitvoeren zonder aannames over structuur of verstrengelingslimieten. Het werk vestigt een nieuwe basislijn voor hoogwaardige quantumsimulatie en biedt een hulpmiddel voor het verifiëren van quantumalgoritmen en het bestuderen van ruiseffecten met een nauwkeurigheidsniveau dat niet haalbaar is met huidige quantumhardware. De auteurs merken op dat toekomstig werk zal focussen op verdere fijnafstelling van buffergroottes en stream-aantallen voor het GH200-platform en het optimaliseren van circuitstructuren om communicatie-overschotten te minimaliseren.