A superconducting surface-code processor with lattice-surgery logical operations

Dit artikel rapporteert de experimentele realisatie van fouttolerante lattice-surgery operaties op een supergeleidende surface-code processor, waarbij hoogwaardige logische Bell-toestandpreparatie, een logisch Deutsch-Jozsa algoritme en non-Clifford gate teleportatie worden gedemonstreerd om een veelzijdig paradigma voor schaalbare kwantumcomputatie te vestigen.

De kern

Stel je voor dat je een kwetsbare boodschap probeert te versturen over een stormachtige oceaan. Als je een enkel papieren bootje stuurt, zal een enkele golf het laten zinken. Maar als je een massieve, versterkte vlot bouwt van vele kleinere bootjes die aan elkaar zijn geknoopt, kan het vlot de golven overleven, zelfs als een paar individuele bootjes beschadigd raken. Dit is het basisidee achter Quantum Error Correction (kwantumfoutcorrectie): het gebruik van vele fysieke "bootjes" (qubits) om één enkel stuk informatie (een logische qubit) te beschermen.

Dit artikel beschrijft een grote stap voorwaarts in het bouwen van dat vlot, specifiek met behulp van een ontwerp genaamd de Surface Code op een supergeleidende computerchip. Hier is wat de onderzoekers hebben bereikt, eenvoudig uitgelegd:

1. De Opstelling: Het Bouwen van het Vlot

Het team bouwde een rooster van 125 kleine supergeleidende "bootjes" (qubits) op een chip. Ze organiseerden deze in twee aparte "vlotten" (logische qubits), die elk uit 17 fysieke bootjes bestaan.

• De Uitdaging: In de echte wereld zijn deze bootjes onrustig. Ze drijven af, lekken energie en maken fouten.
• De Oplossing: Ze controleerden constant het "weer" (het meten van foutsyndromen) om te zien of er bootjes aan het afdrijven waren. Als een bootje begon af te drijven, konden ze dit corrigeren voordat het hele vlot zonk. Ze bewezen dat hun vlot vele rondes van deze controles kon overleven, met een zeer lage kans dat de hele boodschap corrupt raakte.

2. De Magische Truc: Het Samenvoegen en Splitsen van Vlotten (Lattice Surgery)

Het meest opwindende deel van het artikel is een techniek genaamd Lattice Surgery. Denk aan dit als een manier om berekeningen uit te voeren op twee aparte vlotten zonder de bootjes fysiek te verplaatsen.

• Samenvoegen: Stel je voor dat je twee aparte vlotten hebt die naast elkaar drijven. Om een berekening uit te voeren, bind je ze tijdelijk aan elkaar tot één groot, langgerekt vlot.
• De Meting: Terwijl ze aan elkaar geknoopt zijn, meet je een specieke eigenschap van het gecombineerde vlot. Dit vertelt je iets over de relatie tussen de twee oorspronkelijke vlotten.
• Splitsen: Je ontknoopt ze vervolgens weer, waardoor ze terug worden gescheiden in twee afzonderlijke vlotten.

Omdat de kwantummechanica werkt zoals het werkt, is dit proces van het aan elkaar knopen en ontknopen niet alleen een meting; het verstrengelt hen. Het is alsoam met het nemen van twee aparte toverstokken, ze tegen elkaar aan te houden, en ze dan weer uit elkaar te trekken zodat ze nu magisch verbonden zijn: als je de ene beweegt, beweegt de andere direct mee, ongeacht hoe ver ze uit elkaar zijn.

3. Wat Ze Eigenlijk Hebben Gedaan

De onderzoekers gebruikten deze "aan elkaar knopen en ontknopen"-methode om drie specifieke dingen te doen:

• Een "Kwantum Tweeling" Creëren (Bell State): Ze begonnen met twee aparte logische vlotten, voegden ze samen en splitsten ze weer. Het resultaat was twee logische qubits die perfect met elkaar verbonden (verstrengeld) waren. Ze bewezen dat deze link echt en sterk was, zelfs met de ruis in het systeem.
• Een Logische Puzzel Oplossen (Deutsch-Jozsa Algoritme): Ze gebruikten hun verbonden vlotten om een specifieke logische puzzel op te lossen. In deze puzzel moet je ontdekken of een verborgen machine altijd hetzelfde antwoord geeft of dat hij een mix van antwoorden geeft. Hun kwantumvlot loste dit veel vaker correct op dan een "ruw" (niet-gecorrigeerd) systeem zou kunnen, wat aantoont dat de foutcorrectie de computer daadwerkelijk beter liet denken.
• De "Onmogelijke" Draai (Non-Clifford Gates): Standaard kwantumcomputers kunnen gemakkelijk een aantal draaiingen (rotaties) uitvoeren, maar ze hebben moeite met een specifiek type draaiing die een "non-Clifford" rotatie wordt genoemd. Om dit te doen, gebruikten het team een speciale truc:
  1. Ze bereidden een speciale "magische ingrediënt" (een magic state) voor op één vlot.
  2. Ze voegden de vlotten samen om deze magie over te dragen naar het andere vlot.
  3. Ze splitsten de vlotten, waarmee ze effectief een complexe draai uitvoerden die normaal gesproken erg moeilijk is.
     Ze lieten zien dat ze dit met een hoge nauwkeurigheid (ongeveer 94% fidelity) konden doen wanneer ze de runs waarbij fouten werden gedetecteerd, eruit filterden.

4. De Kern van het Verhaal

Het artikel beweert dat Lattice Surgery een praktische, werkende methie is om complexe berekeningen op een kwantumcomputer uit te voeren.

• Ze hebben niet alleen een geheugenstick gebouwd die gegevens opslaat; ze hebben een processor gebouwd die ook berekeningen kan uitvoeren op die gegevens.
• Ze bewezen dat door deze logische "vlotten" samen te voegen en te splitsen, ze verstrengeling kunnen creëren, algoritmen kunnen draaien en complexe draaiingen kunnen uitvoeren.
• Hoewel het systeem nog groter en perfecter moet worden om problemen uit de echte wereld op te lossen, bewijst dit experiment dat de fundamentele bouwstenen voor een schaalbare, fouttolerante kwantumcomputer naar behoren werken.

Kortom, ze hebben succesvol aangetoond dat je twee aparte, foutgecorrigeerde kwantum-"vlotten" kunt nemen, ze aan elkaar kunt knopen om een berekening uit te voeren, en ze weer uit elkaar kunt halen om een nuttig, verstrengeld resultaat te krijgen. Dit is een cruciale mijlpaal op de weg naar het bouwen van een kwantumcomputer die daadwerkelijk problemen kan oplossen.

Technische samenvatting

Technische Samenvatting: Een Supergeleidende Surface-Code Processor met Lattice-Surgery Logische Operaties

Probleemstelling
Schaalbare kwantumcomputatie vereist fouttolerante logische operaties die voorkomen dat laag-gewicht fysieke fouten uitmonden in oncorrigeerbare logische defecten. Hoewel de surface code een leidende kandidaat is voor kwantumfoutcorrectie (QEC) vanwege de hoge drempelwaarde en compatibiliteit met planaire lay-outs, heeft de experimentele vooruitgang zich grotendeels gericht op het demonstreren van herhaalde syndroomextractiecycli (SEC's) en logische geheugenslevensduur die de break-even punt overschrijden. De kritieke resterende uitdaging is het implementeren van logische operaties die de fouttolerantie behouden binnen de strikte beperkingen van statische, tweedimensionale supergeleidende architecturen. Terwijl transversale operaties fouttolerantie bieden, vereisen ze niet-lokale connectiviteit die niet beschikbaar is in planaire systemen. Lattice surgery, waarbij code-patches dynamisch worden vervormd om operaties uit te voeren, is de voorgestelde oplossing voor dergelijke platforms, maar de directe demonstratie ervan tussen volledig foutcorrigeerbare surface-code patches en de realisatie van niet-Clifford logische gates blijven uitstaande experimentele uitdagingen.

Methodologie
De auteurs hebben fundamentele lattice-surgery operaties gerealiseerd op een planaire supergeleidende processor bestaande uit 125 verstelbare transmon-qubits. Het systeem huisvest twee logische qubits, $L_1$ en $L_2$, elk gecodeerd in een afstand-drie geroteerde surface code (9 data-qubits en 8 syndroom-qubits per patch).

De kernmethodologie omvat:

1. Lattice Merge en Split: Om gezamenlijke logische operaties uit te voeren, worden de twee disjuncte code-patches samengevoegd tot een enkele verlengde $7 \times 3$ geroteerde surface code ($L_3$) door de syndroomextractie-circuits dynamisch te herconfigureren. Dit houdt het uitbreiden van boundary-stabilizers in en het introduceren van ancilla data- en syndroom-qubits. De logische Pauli-operatoren worden gemeten via de pariteit van de syndroomrecords. De patches worden vervolgens weer gesplitst in $L_1$ en $L_2$ door de ancilla data-qubits in de $Z$-basis te meten en de oorspronkelijke stabilizer-gewichten te herstellen.
2. Toestandsvoorbereiding en Correctie: Logische Bell-toestanden worden deterministisch gegenereerd via een lattice-split protocol, waarbij gebruik wordt gemaakt van Pauli-frame updates geconditioneerd op tussenliggende meetresultaten om te corrigeren voor meet-geïnduceerde fouten.
3. Algoritmische Executie: Een twee-qubit Deutsch-Jozsa algoritme wordt op logisch niveau uitgevoerd. De kwantum-oracle wordt geïmplementeerd via lattice surgery, waarbij onderscheid wordt gemaakt tussen constante en gebalanceerde Booleaanse functies.
4. Niet-Clifford Operaties: Universele controle wordt bereikt door magic-state injectie en gate teleportatie. Een high-fidelity magic state wordt voorbereid op $L_2$ en geconsumeerd om willekeurige logische $R_X(\theta)$ rotaties op $L_1$ uit te voeren via een gezamenlijke $M_{XX}$ meting (gerealiseerd door merge/split operaties).
5. Fouthandeling: De studie maakt gebruik van een belief-matching decoder voor foutcorrectie en gebruikt "gedetecteerde-foutvrije" post-selectie (het verwerpen van runs met niet-triviale syndromen of leakage-events) om de prestatie-bovengrens te benchmarken.

Belangrijkste Bijdragen

• Experimentele Realisatie van Lattice Surgery: De eerste directe demonstratie van lattice-merge en lattice-split operaties tussen twee afstand-drie surface-code logische qubits op een supergeleidende processor.
• Logische Verstrengeling: Deterministische voorbereiding van een logische Bell-toestand ($|\Phi^+\rangle_L$) over de twee surface-code patches, wat simultane bescherming biedt tegen bit-flip en phase-flip fouten.
• Uitvoering van Logische Algoritmen: Succesvolle implementatie van het Deutsch-Jozsa algoritme op logisch niveau, wat de algoritmische bruikbaarheid binnen een fouttolerante framework demonstreert.
• Implementatie van Niet-Clifford Gates: Realisatie van continue niet-Clifford logische rotaties rond de logische $X$-as via magic-state injectie en gate teleportatie, een noodzakelijk onderdeel voor universele kwantumcomputatie.

Resultaten

• Logische Geheugenprestaties: Na het verwerpen van leakage-events vertoonden de logische qubits per-cyclus foutpercentages van $\epsilon_{L1} = 0.0365(2)$ en $\epsilon_{L2} = 0.0282(1)$.
• Bell-toestand Fidelity: De ruwe toestand-fidelity was $0.372$. Met behulp van een belief-matching decoder verbeterde de fidelity ondergrens naar $F_{dec} = 0.532$, wat genuante bipartite verstrengeling bevestigt. Onder gedetecteerde-foutvrije post-selectie bereikte de fidelity $F_{pst} = 0.925$.
• Deutsch-Jozsa Nauwkeurigheid: Foutcorrectie verbeterde de classificatienauwkeurigheid aanzienlijk. Voor constante functies steeg de nauwkeurigheid van $0.886$ (ruw) naar $0.970$ (gedecodeerd). Voor gebalanceerde functies verbeterde deze van $0.623$ naar $0.716$. Post-selectie verhoogde deze waarden verder naar bijna eenheid, hoewel dit ten koste ging van het behouden van slechts $0.06\%$ van de data voor de gebalanceerde case.
• Niet-Clifford Gate Fidelity: Voor de logische $R_X(\pi/4)$ gate lieten de foutgecorrigeerde resultaten een bescheiden verbetering zien ten opzichte van de ruwe data. Onder gedetecteerde-foutvrije post-selectie bereikte de logische gate fidelity $0.943^{+10}_{-9}$.

Betekenis
De auteurs stellen dat deze resultaten lattice surgery vestigen als een praktische en veelzijdige paradigma voor logische computatie in nabije surface-code architecturen. Door de volledige stack van operaties te demonstreren — van geheugenbehoud en generatie van verstrengeling tot algoritmische executie en universele gate implementatie — vormt dit werk een cruciale mijlpaal naar schaalbare fouttolerante kwantumvoorsprong in supergeleidende circuits. Het artikel positioneert deze bevindingen als de essentiële bouwstenen die vereist zijn voor de transitie van geïsoleerde kwantumgeheugens naar programmeerbare fouttolerante processors.