PHOENIX: Pauli-Based High-Level Optimization Engine for Instruction Execution on NISQ Devices

Dit paper introduceert PHOENIX, een geavanceerde compilatieframework dat variational quantum algoritmes voor Hamilton-simulatie optimaliseert door te werken op een Pauli-gebaseerde tussenrepresentatie, waardoor het aanzienlijk betere prestaties levert dan bestaande state-of-the-art methoden op diverse NISQ-hardware.

De kern

Stel je voor dat je een heel ingewikkeld recept wilt koken voor een quantumcomputer. Maar deze computer is nog niet perfect; hij is wat "ruisachtig" (zoals een radio met statische storing) en de ingrediënten (de qubits) zijn beperkt.

Het artikel dat je hebt gestuurd, introduceert PHOENIX. Dit is geen nieuwe oven of een nieuw fornuis, maar een super-slave kok die het recept herschrijft voordat het überhaupt naar de keuken wordt gebracht.

Hier is hoe het werkt, vertaald naar alledaagse taal:

1. Het Probleem: De "Bouwpakket"-Methode

Normaal gesproken proberen quantum-programma's (zoals die voor het simuleren van nieuwe medicijnen) een complex proces na te bootsen door stap voor stap kleine, simpele bewegingen uit te voeren.

• De oude manier: Stel je voor dat je een muur moet bouwen. De traditionele compilatoren (de software die het recept vertaalt) kijken naar elke baksteen afzonderlijk. Ze zeggen: "Oké, hier een baksteen, dan een beetje cement, dan nog een baksteen." Ze proberen alleen de bakstenen die direct naast elkaar liggen te optimaliseren.
• Het resultaat: Je bouwt een muur, maar hij is vaak veel groter en onnodig complex dan nodig. Veel bewegingen annuleren elkaar op, maar de software ziet dat niet omdat ze te lokaal kijken.

2. De Oplossing: PHOENIX (De "Hoofdkok")

PHOENIX kijkt niet naar elke baksteen apart. Het kijkt naar het hele bouwpakket in één keer.

• De Analogie: In plaats van te zeggen "leg hier een baksteen", zegt PHOENIX: "Wacht even, als we deze hele groep bakstenen in een andere volgorde leggen en een paar van die cementlaagjes weglaten, kunnen we de hele muur in de helft van de tijd bouwen."
• De Wiskunde (simpel gehouden): PHOENIX gebruikt een speciale manier van noteren (genaamd "Pauli-strings") om te zien welke bewegingen eigenlijk hetzelfde doen. Het gebruikt een soort "magische transformatie" (Clifford-transformaties) om de hele lijst van instructies te herschrijven voordat het begint met bouwen.

3. De Twee Stappen van PHOENIX

Stap 1: Het "Tetris" van de instructies

Stel je voor dat je een doos vol Tetris-blokken hebt die je in een koffer moet proppen.

• De oude methode: Je plakt de blokken één voor één in de koffer. Als er een gat overblijft, probeer je het met een klein blokje te vullen.
• PHOENIX: Eerst kijkt PHOENIX of het Tetris-blokken kan samenvoegen tot grotere, efficiëntere blokken (dit noemen ze simplificatie). Daarna gebruikt het een slimme strategie om deze blokken in de koffer te leggen. Het probeert niet alleen de blokken te stapelen, maar ook te kijken welke blokken het beste bij elkaar passen zodat er minder ruimte (en minder "reizen" voor de qubits) nodig is.
• Het doel: De koffer (de quantumcircuit) wordt veel kleiner en sneller.

Stap 2: Onafhankelijk van de Keuken

Een groot voordeel van PHOENIX is dat het niet uitmaakt wat voor fornuis je hebt.

• Sommige quantumcomputers werken met één type "gasvlam" (CNOT-gates), anderen met een ander type.
• PHOENIX is als een kok die eerst het recept perfect maakt en pas op het allerlaatste moment zegt: "Ah, jij hebt een elektrisch fornuis? Geen probleem, ik pas de instructies net iets aan."
• Dit betekent dat het werkt op bijna elke quantumcomputer die er nu is of in de toekomst komt.

4. Wat levert het op? (De Resultaten)

De auteurs hebben PHOENIX getest tegen de beste andere software die er nu is.

• Minder fouten: Omdat de quantumcomputer minder bewegingen hoeft te maken, is er minder kans dat de "ruis" (de storing) het resultaat verpest. Het is alsof je een boodschap fluistert in plaats van te schreeuwen; hoe korter de boodschap, hoe minder kans op misverstand.
• Enorme besparing: In sommige tests kon PHOENIX het aantal benodigde bewegingen (gates) met wel 80% verlagen vergeleken met de oude methoden.
• Sneller: De circuits (de recepten) zijn veel korter, wat betekent dat de berekening sneller klaar is voordat de qubits "vergeten" wat ze moesten doen.

Samenvattend

PHOENIX is een slimme software die quantum-recepten niet woord voor woord vertaalt, maar eerst de hele zin begrijpt, de overbodige woorden verwijdert, de zinnen herschrijft voor meer duidelijkheid, en pas dan vertaalt naar de specifieke taal van de quantumcomputer.

Het is alsof je van een stapel losse, ongestructureerde postkaarten (de oude methode) naar een perfect geordend, compact boekje gaat (PHOENIX). Hierdoor kan de quantumcomputer veel moeilijke problemen oplossen, zoals het ontwerpen van nieuwe medicijnen, zonder vast te lopen in de beperkingen van de huidige hardware.

Technische samenvatting

Probleemstelling

Variational Quantum Algorithms (VQA), zoals VQE en QAOA, zijn veelbelovend voor het Noisy Intermediate-Scale Quantum (NISQ)-tijdperk vanwege hun bescheiden eisen aan het aantal qubits en de diepte van de schakelingen. Deze algoritmen simuleren vaak Hamiltonian-evolutie door de tijd te discretiseren (Trotterisatie) in een reeks Pauli-exponentiaties.

De huidige staat-van-de-kunst (SOTA) compilers (zoals TKET, PAULIHEDRAL, TETRIS) hebben echter beperkingen:

1. Lokale optimalisatie: Ze werken voornamelijk op het niveau van reeds gegenereerde subcircuits of lokale patronen (bijv. CNOT-bomen), waardoor ze globale optimalisatiemogelijkheden missen.
2. ISA-afhankelijkheid: Veel methoden zijn sterk gebonden aan specifieke instructie-set architecturen (ISA), zoals de CNOT-basis, en zijn minder flexibel voor nieuwe of continue gate-sets.
3. Suboptimale ordening: De manier waarop Pauli-termen worden gerangschikt en samengevoegd, beïnvloedt de uiteindelijke schakelingsdiepte en het aantal benodigde 2-qubit gates (zoals CNOT of SWAP) aanzienlijk, maar bestaande methoden benutten dit niet optimaal.

Het doel is om een compilatieframework te ontwikkelen dat op een hoger semantisch niveau werkt, globale optimalisaties toepast en hardware-onafhankelijk is.

Methodologie: PHOENIX

PHOENIX (Pauli-based High-level Optimization ENgine for Instruction eXecution) is een compilatieframework dat werkt volgens een drie-staps pipeline: IR-groepering → Groepsweise vereenvoudiging → Ordening van IR-groepen.

1. Formele Representatie: Binary Symplectic Form (BSF)

In plaats van te werken met gate-sequenties, representeert PHOENIX Pauli-strings in een Binary Symplectic Form (BSF).

• Elke $n$-qubit Pauli-string wordt weergegeven als een rij in een tabel met kolommen voor $X$ en $Z$ blokken.
• De codering is: $X \to [1|0]$, $Z \to [0|1]$, $Y \to [1|1]$, en $I \to [0|0]$.
• Het synthese-probleem wordt herschreven als het verminderen van de "kolomgewichten" van de BSF door middel van geschikte Clifford-transformaties.

2. Groepsweise Vereenvoudiging (BSF Simplification)

Pauli-exponentiaties worden eerst gegroepeerd op basis van de qubit-indexen waarop ze niet-triviaal inwerken. Voor elke groep wordt een heuristisch algoritme toegepast:

• Doel: Het verminderen van het totale gewicht ($w_{tot}$) van de BSF tot $\le 2$. Een gewicht van 2 betekent dat de term direct kan worden gesynthetiseerd met basis 1-qubit en 2-qubit gates.
• Methode: Het algoritme zoekt iteratief naar de meest geschikte 2-qubit Clifford-operatoren (uit een set van zes universele gecontroleerde gates) die het grootste gewichtsverlies in de BSF opleveren.
• Cost Function: Een heuristische kostenfunctie ($cost_{bsf}$) wordt gebruikt om de disparity tussen de huidige BSF en de gewenste staat te kwantificeren, rekening houdend met het aantal niet-lokale Pauli-strings en overlap tussen $X$- en $Z$-delen.
• Resultaat: Een vereenvoudigde IR-groep bestaande uit Clifford-conjugaties en Pauli-exponentiaties met gewicht $\le 2$, nog steeds onafhankelijk van de specifieke hardware-ISA.

3. Tetris-achtige Ordening (Global Ordering)

Nadat de groepen zijn vereenvoudigd, moeten ze in een specifieke volgorde worden geplaatst om de totale schakelingsdiepte te minimaliseren. PHOENIX gebruikt een "Tetris-achtige" strategie:

• Endian Vectors: Elke subcircuit wordt gemodelleerd als een Tetris-blok met linker- en rechter-endian vectoren ($e_l, e_r$), die aangeven hoeveel lagen er nodig zijn om een qubit te bereiken vanaf de randen.
• Kostenfunctie: De kosten voor het samenvoegen van twee subcircuits worden berekend op basis van:
  1. Schakelingsdiepte: Gebaseerd op de overlap van de endian vectoren.
  2. Gate Cancellatie: Mogelijkheden om Clifford2Q-gates aan de grenzen van subcircuits te annuleren.
  3. Routing Overhead: Een factor die de gelijkenis meet tussen de interactiegrafieken van qubits van opeenvolgende subcircuits. Hoe meer gelijkenis, hoe minder mapping-overhead (SWAPs) nodig is.
• Het algoritme kiest de volgende subcircuit die de totale kosten minimaliseert, vergelijkbaar met het leggen van Tetris-blokken.

Belangrijkste Bijdragen

1. Hoge-niveau Semantische Optimalisatie: PHOENIX introduceert een nieuwe aanpak die optimalisatie uitvoert op het niveau van de Pauli-IR (via BSF) in plaats van op het niveau van gegenereerde gates, waardoor globale optimalisaties mogelijk zijn die door lokale methoden worden gemist.
2. BSF-gebaseerde Synthese: Het reformuleert de synthese van Pauli-strings als het reduceren van kolomgewichten in een symplectische vorm via Clifford-conjugaties, wat een wiskundig robuuste basis biedt voor vereenvoudiging.
3. Hardware-onafhankelijkheid: Het framework is ISA-onafhankelijk en kan worden toegepast op diverse gate-sets (van CNOT tot continue SU(4)-gates) zonder de kernoptimalisatie te hoeven aanpassen.
4. Geïntegreerde Routing: De ordeningsstrategie combineert gate-cancellatie en qubit-routingoverhead in één kostenfunctie, wat leidt tot efficiëntere schakelingen op beperkte hardware-topologieën.

Resultaten

Het team heeft PHOENIX geëvalueerd op diverse VQA-programma's (UCCSD voor moleculaire simulatie en QAOA voor combinatorische optimalisatie), verschillende back-end ISA's (CNOT en SU(4)) en hardware-topologieën (All-to-All en IBM Heavy-Hex).

• Logische Optimalisatie (All-to-All):
  • PHOENIX reduceerde het aantal CNOT-gates met gemiddeld 80,47% en de 2Q-schakelingsdiepte met 82,7% ten opzichte van de originele logische circuits.
  • Tegenover SOTA-compilers (TKET, PAULIHEDRAL, TETRIS) behaalde PHOENIX een gemiddelde optimalisatie van 21,13% (CNOT) en 19,3% (diepte) bovenop de beste concurrenten.
• Hardware-bewuste Compilatie (Heavy-Hex Topologie):
  • Tegenover PAULIHEDRAL en TETRIS reduceerde PHOENIX het aantal CNOT-gates met respectievelijk 36,17% en 22,62%.
  • De 2Q-diepte werd met 43,85% (vs PAULIHEDRAL) en 28,12% (vs TETRIS) verlaagd.
• ISA-onafhankelijkheid (SU(4) ISA):
  • Bij het targeten van de expressieve SU(4) ISA (waar alle 2-qubit gates natief zijn) was de prestatieverbetering van PHOENIX nog opvallender, met reducties in gate-aantallen van meer dan 75% ten opzichte van bestaande methoden.
• QAOA:
  • Voor QAOA-benchmarks op Heavy-Hex topologie overtrof PHOENIX de SOTA-baseline 2QAN met een gemiddelde reductie van 40,8% in 2Q-diepte.
• Algoritmische Fout:
  • PHOENIX resulteerde in lagere algoritmische fouten (infidelity) vergeleken met TKET, vooral voor Bravyi-Kitaev (BK) encoding, wat dichter bij een kwantumvoordeel voor chemische simulaties brengt.

Betekenis en Conclusie

PHOENIX markeert een verschuiving in de kwantumcompilatie van lokale, gate-gebaseerde herschrijvingsregels naar een globale, semantische optimalisatie op het niveau van Pauli-strings.

• Kwaliteitsverbetering: Door de schakelingsdiepte en het aantal foutgevoelige 2-qubit gates drastisch te verminderen, maakt PHOENIX VQA-algoritmen praktischer uitvoerbaar op huidige, ruisgevoelige hardware.
• Toekomstvisie: Het werk suggereert dat hoge-niveau IR's niet alleen nuttig zijn voor compilatie, maar ook als leidraad kunnen dienen voor het ontwerp van toekomstige kwantumprocessors en besturingssystemen die specifiek zijn afgestemd op het efficiënt uitvoeren van deze hoog-niveau Pauli-bewerkingen.

Kortom, PHOENIX demonstreert dat het benutten van de structuur van Hamiltonian-simulatie op een hoger abstractieniveau aanzienlijke voordelen biedt ten opzichte van traditionele, laag-niveau compilatietechnieken.