Kwantumfoutcorrectie en logische qubits uitgelegd

Hoe kwantumfoutcorrectie veel ruisgevoelige fysieke qubits omzet in betrouwbaardere logische qubits, en waarom codeafstand, drempelwaarden en oppervlaktencodes ertoe doen.

Deze pagina is vertaald vanuit het Engels. Bedrijfs- en productnamen en bronlinks zijn ongewijzigd. Lees het origineel in het Engels

Kwantumfoutcorrectie is het geheel aan methoden waarmee kwetsbare kwantuminformatie bruikbaar blijft ondanks ruis, decoherentie en onvolmaakte bewerkingen. Het basisidee is om één of meer logische qubits te coderen in een grotere verzameling fysieke qubits, herhaaldelijk zorgvuldig gekozen controles te meten die foutinformatie onthullen maar niet de beschermde kwantumtoestand, en vervolgens herstelstappen toe te passen op basis van het waargenomen syndroom.

Waarom quantumcomputers foutcorrectie nodig hebben

Kwantuminformatie is uitzonderlijk kwetsbaar. Fouten kunnen voortkomen uit decoherentie en andere bronnen van kwantumruis, en in praktische quantumcomputing moet men ook rekening houden met gebrekkige poorten, onvolmaakte toestandsvoorbereiding en meetfouten. Daardoor is foutcorrectie niet alleen cruciaal voor het opslaan van kwantumtoestanden, maar ook voor het uitvoeren van lange berekeningen.

Klassieke foutcorrectie werkt door redundantie aan bits toe te voegen. Kwantumfoutcorrectie beoogt iets vergelijkbaars, maar met een belangrijke beperking: directe meting van een qubit verstoort de toestand doorgaans. Een quantumcode moet dus informatie over wat er misging kunnen extraheren zonder de logische informatie zelf prijs te geven. In veel codes gebeurt dit via metingen van commutatieve operatoren die stabilisatoren worden genoemd.

Een nuttige manier om naar de belofte van kwantumfoutcorrectie te kijken, is als een simulatielaag: gegeven een ruisgevoelig fysiek kanaal dat binnen een bepaald foutmodel past, kan een kwantumfoutcorrigerende code worden gebruikt om een ruisvrij logisch kanaal goed genoeg te benaderen om communicatie of berekening praktisch te maken.

Fysieke qubits, logische qubits en codeafstand

Een standaardnotatie voor een quantumcode is [[n,k,d]], wat betekent dat de code k logische qubits codeert in n fysieke qubits met codeafstand d.

Die drie parameters vatten de meeste afwegingen samen:

n: hoeveel fysieke qubits de code gebruikt
k: hoeveel logische qubits worden beschermd
d: de codeafstand, een maat die samenhangt met hoe moeilijk het is voor fouten om zich te gedragen als een logische bewerking

De coderatio, k/n, is een basale efficiëntiemaatstaf. Een hogere ratio betekent minder overhead per logische qubit. Maar grotere codeafstand en hogere ratio werken elkaar doorgaans tegen, dus codeontwerp draait om het afwegen van betrouwbaarheid tegen hardwarekosten.

In grote lijnen kent een cyclus van kwantumfoutcorrectie drie fasen:

Codering van logische informatie in een groter fysiek systeem
Opslag of transmissie via een ruisgevoelig kanaal
Syndroomextractie en herstel, waarbij waarschijnlijke fouten worden geïdentificeerd en gecorrigeerd

Het syndroom is cruciaal. Stabilisatormetingen worden zo gekozen dat ze alleen foutinformatie onthullen, niet de gecodeerde kwantumtoestand. Anders zou het correctieproces de superposities vernietigen die de computer probeert te behouden.

Op welke soorten fouten richten codes zich?

Welke fouten dominant zijn, hangt sterk af van het hardwareplatform. Belangrijke voorbeelden zijn:

Amplitudedemping, of verlies van excitatie, geassocieerd met relaxatie naar evenwicht
Coherente fouten, die voortkomen uit de interne dynamica van het systeem
Defasering, een van de dominante ruisprocessen in veel qubitimplementaties

Toch werken veel quantumcodes met een vereenvoudigd model waarin fouten worden behandeld als combinaties van Pauli-bewerkingen:

X voor bitflip-achtige fouten
Z voor faseflip-achtige fouten
Y voor gecombineerde bit- en fasefouten

Dit op Pauli-operatoren gebaseerde beeld vangt niet elk realistisch ruisproces, maar wordt veel gebruikt omdat het analyse en codeconstructie beter hanteerbaar maakt. Binnen dat model kunnen syndroomextractie en decodering vaak worden geformuleerd op manieren die ideeën ontlenen aan de klassieke coderingstheorie.

Die vereenvoudiging kent wel een kanttekening: decodering kan nog steeds moeilijk zijn. Een code met parameters [[n,k,d]] heeft 2^(n-k) mogelijke syndromen, wat al snel te groot wordt voor eenvoudige opzoektabellen. In de praktijk zijn daarom meestal efficiënte klassieke decoderingsalgoritmen nodig.

Fouttolerantie: fouten corrigeren zonder het erger te maken

Foutcorrectie alleen is niet genoeg voor schaalbare berekeningen. In een computer gebruikt het correctiemechanisme zelf poorten, metingen en voorbereide ancilla's die allemaal kunnen falen. Hier komt fouttolerantie om de hoek kijken.

Het centrale idee is om codering, syndroommeting en herstel zo te ontwerpen dat een klein aantal fysieke fouten zich niet uitbreidt tot een niet-corrigeerbare logische fout. Kwantumfoutcorrectie koppelt dit aan het kwantumdrempeltheorema: willekeurig lange kwantumberekeningen zijn mogelijk door codes recursief te concatenëren, mits het foutenpercentage van individuele kwantumpoorten onder een drempel blijft.

Quantum error correction geeft een historische schatting uit 2004 dat deze drempel wel 1–3% zou kunnen bedragen, aangenomen dat er voldoende qubits beschikbaar zijn. Het geeft ook de intuïtie waarom zo'n drempel ertoe doet: daaronder verwijdert correctie meer fouten dan zij introduceert; daarboven kan het correctieproces per saldo schadelijk worden.

Dit drempelconcept is een van de redenen waarom logische qubits zo'n nuttige abstractie zijn. Een logische qubit is geen enkel apparaatelement, maar een gecodeerd object waarvan de effectieve foutkans in principe verder kan worden verlaagd door meer fysieke middelen toe te voegen en betere fouttolerante procedures te gebruiken.

Belangrijke codefamilies en wat zij optimaliseren

Verschillende codefamilies maken verschillende afwegingen tussen overhead, afstand, structuur en implementeerbaarheid.

Codefamilie	Kernidee	Opvallende afweging of eigenschap
Shor-code	Generaliseert naar `[[d^2,1,d]]`; gebruikt binnenste en buitenste herhalingscodes om bitflip- en faseflipfouten afzonderlijk af te handelen	Vergroot de afstand, maar met een lagere coderatio
Steane- / quantum-Hamming-codes	Vervangt de herhalingsstructuur door de klassieke `[7,4]`-Hamming-code en behandelt `X`- en `Z`-fouten symmetrisch	Betere coderatio dan herhalingscodes in Shor-stijl
CSS-codes	Algemeen raamwerk afgeleid van verwante constructies van Calderbank, Shor en Steane	Scheidt `X`- en `Z`-stabilisatoren, wat nuttig is voor fouttolerante syndroommeting
Vijf-qubitcode	Gebruikt vier stabilisatoren die `X` en `Z` mengen; geen CSS-code	Kleinst mogelijke code die één logische qubit beschermt tegen willekeurige enkelqubitfouten
Oppervlaktencode	Topologische stabilisatorcode op een 2D-rooster	Lokale controles en een planaire lay-out zijn experimenteel aantrekkelijk

De vijf-qubitcode is conceptueel bijzonder belangrijk. Het is de kleinst mogelijke code die één logische qubit kan beschermen tegen willekeurige enkelqubitfouten, een feit dat samenhangt met de kwantum-Hamming-grens.

Quantum error correction noemt ook niet-additieve codes, die buiten het stabilisatorformalisme vallen dat wordt gebruikt door additieve [[n,k,d]]-codes. Die kunnen in sommige gevallen hogere coderatio's halen, maar zijn aanzienlijk moeilijker te construeren en te analyseren, en daarom minder uitgebreid onderzocht.

Waarom oppervlaktencodes zo belangrijk werden

Onder moderne codefamilies zijn oppervlaktencodes in 2025 cruciaal voor schaalbare kwantumfoutcorrectie. De belangrijkste reden is architectonisch: ze zijn gedefinieerd via lokale stabilisatormetingen op een tweedimensionaal rooster, wat voor veel hardwareplatforms gunstiger is dan codes die interacties over lange afstand vereisen.

De oppervlaktencode is een topologische stabilisatorcode. In de torische versie die in 1997 werd geïntroduceerd door Alexei Kitaev, bevinden qubits zich op de randen van een 2D-rooster en zijn stabilisatoren gekoppeld aan hoekpunten en plaquettes. Fouten verschijnen als schendingen van deze stabilisatoren.

Een nuttig beeld is dat een fout gelokaliseerde defecten creëert of verplaatst, beschreven als anyonen:

een Z-fout klapt naburige hoekpuntstabilisatoren om
een X-fout klapt naburige plaquettestabilisatoren om

Correctie komt neer op het koppelen en opnieuw annihileren van deze defecten. Als de resulterende paden topologisch triviaal zijn, is het netto-effect slechts een stabilisator en blijft de logische informatie onveranderd. Als een pad topologisch niet-triviaal is, werkt het proces als een logische operator en verandert de gecodeerde informatie.

Die geometrische interpretatie is een van de redenen waarom oppervlaktencodes zo intuïtief zijn. Codeafstand wordt dan de minimale lengte van een niet-triviaal pad of een niet-triviale lus die een logische fout implementeert.

Torische, planaire en geroteerde planaire oppervlaktencodes

Verschillende verwante geometrieën zijn belangrijk.

De torische code gebruikt periodieke randvoorwaarden en is topologisch equivalent aan een torus. Voor een d × d-rooster heeft die 2d^2 qubits, en de coderuimte is vierdimensionaal, zodat er twee logische qubits in worden opgeslagen.

Voor hardware zijn open randen vaak praktischer, wat leidt tot de planaire code. Maar het randontwerp is belangrijk. Een oppervlaktencode met slechts één type rand codeert geen logische qubit. Om een niet-triviale coderuimte te creëren, zijn afwisselende gladde en ruwe randen nodig. Met gladde boven- en onderranden en ruwe linker- en rechterranden slaat de planaire code één logische qubit op, en hebben de minimaal topologisch niet-triviale paden lengte d, wat een codeafstand d oplevert.

De geroteerde planaire code is een efficiëntieverbetering. Surface code stelt dat een geroteerde planaire code met afstand d d^2 fysieke qubits gebruikt, tegenover d^2 + (d − 1)^2 voor de niet-geroteerde planaire versie, terwijl dezelfde codeafstand behouden blijft.

Drempelwaarden, decodering en wat “onder de drempel” betekent

Oppervlaktencodes vallen ook op door relatief hoge drempelwaarden onder standaardruismodellen. Voor een model waarin bit- en fasefouten onafhankelijk optreden op elke qubit met kans p, meldt Surface code:

een kritische kans van ongeveer 11% uit een afbeelding op de statistische fysica
ongeveer 10.5% bij gebruik van de veelgebruikte decoder minimum weight perfect matching

Die getallen zijn belangrijk, maar vragen om duiding. Ten eerste hangen ze af van het veronderstelde foutmodel. Ten tweede is de theoretische limiet alleen nuttig als er een praktische decoder bestaat die daarbij in de buurt komt. Ten derde presteren sommige decoders slechter wanneer bit- en fasefouten gecorreleerd zijn, zoals onder depolariserende ruis.

Dus “onder de drempel” betekent niet dat een systeem foutvrij is. Het betekent dat, in principe, het vergroten van de codegrootte de logische foutkans kan verlagen in plaats van de situatie te verslechteren.

Verder dan blokcodes met qubits

Kwantumfoutcorrectie is breder dan qubit-op-qubit-blokcodes. Kwantuminformatie kan worden gecodeerd in qudits of in oscillatoren, die oneindig veel energieniveaus hebben. Bosonische benaderingen zoals kat-, GKP- en binomiale ideeën benutten redundantie binnen één enkele oscillator in plaats van één logische qubit over veel twee-niveausystemen te verspreiden.

Dat onderstreept een belangrijke open ontwerpvraag voor het vakgebied: moet redundantie worden ondergebracht over veel fysieke qubits, binnen hoger-dimensionale systemen, of in hybriden van beide?

Waar het veld in 2025 staat

Oppervlaktencodes zijn in 2025 bijzonder belangrijk. Quantum error correction stelt dat ze logische qubits onder de drempel mogelijk maken met verbeterde fideliteit in supergeleidingssystemen, en merkt afzonderlijk op dat Google Quantum AI een distance-7 planar code heeft geïmplementeerd op zijn supergeleidende Willow-processor, waarmee een fysieke foutkans onder de drempel werd aangetoond.

Dat betekent niet dat de bredere uitdaging is opgelost. Logische qubits vereisen nog steeds aanzienlijke overhead, decodering blijft een reëel systeemprobleem en prestaties hangen af van het afstemmen van de codekeuze op de werkelijke hardwareruis. Maar het laat wel zien waarom logische qubits nu een praktisch technisch doel zijn in plaats van alleen een theoretisch construct.

Belangrijkste punten

Kwantumfoutcorrectie beschermt kwetsbare kwantuminformatie door logische qubits te coderen in grotere fysieke systemen en herhaaldelijk foutsyndromen te extraheren.
De standaardnotatie [[n,k,d]] vat de belangrijkste afweging samen: fysieke overhead versus beschermde logische capaciteit en codeafstand.
De meest gebruikte codes vereenvoudigen hardwareruis tot Pauli-fouten X, Y en Z, ook al vertonen echte apparaten ook effecten zoals amplitudedemping en defasering.
Fouttolerantie is belangrijk omdat het correctieproces zelf ruisgevoelig is; het drempeltheorema zegt dat schaalbare berekening alleen mogelijk is onder een bepaalde fysieke foutkans.
De vijf-qubitcode is de kleinste code die één logische qubit kan beschermen tegen willekeurige enkelqubitfouten.
CSS-codes worden gewaardeerd omdat zij X- en Z-stabilisatoren scheiden, wat helpt bij fouttolerante syndroommeting.
Oppervlaktencodes zijn prominent omdat hun stabilisatoren lokaal zijn op een 2D-rooster, wat ze experimenteel aantrekkelijk maakt.
In oppervlaktencodes komt logische mislukking overeen met topologisch niet-triviale foutpaden; codeafstand is de minimale grootte van zo'n pad.
Geroteerde planaire oppervlaktencodes verminderen het aantal qubits ten opzichte van niet-geroteerde planaire codes, terwijl de afstand behouden blijft.
Gerapporteerde drempelwaarden en recente demonstraties zijn bemoedigend, maar praktische prestaties blijven afhangen van hardwareruis, de kwaliteit van de decoder en grote overhead in fysieke qubits.