Junction Hook Errors in the Color Code

In de zoektocht naar het bouwen van een werkende kwantumcomputer proberen wetenschappers een probleem van extreme fragiliteit op te lossen. De basisunits van informatie, qubits genoemd, zijn zo gevoelig dat de kleinste verstoring de gegevens die ze bevatten kan corrumperen. Om dit te bestrijden, gebruiken onderzoekers foutcorrectiecodes, die een enkel stuk informatie verspreiden over vele fysieke qubits, waardoor een vangnet ontstaat. Als één qubit faalt, kunnen de anderen de fout onthullen en herstellen zonder de informatie te vernietigen. Eén veelbelovend ontwerp voor dit vangnet is de driehoekige kleurcode, een patroon van qubits gerangschikt in een driehoek waarbij drie verschillende kleuren—rood, groen en blauw—op een specifieke manier met elkaar interageren. Het doel is om deze codes robuust genoeg te maken om complexe berekeningen uit te voeren, maar een hardnekkige dreiging die "hook errors" (haakfouten) wordt genoemd, heeft dit moeilijk gemaakt. Deze fouten treden op wanneer een enkele fout in het meetproces zich verspreidt naar meerdere dataqubits, wat potentieel een kettingreactie kan veroorzaken die lijkt op een legitiem stuk informatie in plaats van een fout.

Een recente studie door Salahedeen Issa en Margaret Martonosi aan de Princeton University onderzoekt een nieuwe methode om deze codes te meten, een methode die voorheen werd geacht het probleem van de haakfouten te hebben opgelost. De onderzoekers ontdekten dat hoewel de nieuwe methode veel soorten gevaarlijke fouten succesvol vermijdt, het een specifieke, over het hoofd geziene kwetsbaarheid achterlaat. Ze ontdekten een nieuwe klasse fouten, die ze "junction hook errors" (knooppunt-haakfouten) noemen, die nog steeds door de mazen van het net kunnen glippen. Deze fouten treden op op het precieze punt waar de drie gekleurde paden van informatie in het midden van de code samenkomen. De studie laat zien dat deze fouten subtiel genoeg zijn om het huidige veiligheidsschema te ontwijken, wat betekent dat de code, zelfs met de nieuwe methode, niet zo veilig is als voorheen werd aangenomen, tenzij er extra bescherming aan het gehele systeem wordt toegevoegd, en niet alleen aan de randen.

Om de betekenis van deze ontdekking te begrijpen, moet men eerst visualiseren hoe informatie door een driehoekige kleurcode reist. Stel je een grote driehoek voor gemaakt van kleine tegels, waarbij elke tegel een dataqubit vertegenwoordigt. De code is zo ontworpen dat informatie van de ene kant van de driehoek naar de andere kan stromen in drie verschillende kleuren. Een logisch stuk informatie, de werkelijke data die wordt beschermd, kan worden beschouwd als een pad gemaakt van deze gekleurde snaren. In het meest efficiënte pad zou een rode snaar bijvoorbeeld bij de rode zijde kunnen beginnen, een groene snaar bij de groene zijde en een blauwe snaar bij de blauwe zijde. Deze drie snaren reizen naar binnen totdat ze samenkomen in één enkel punt in het midden van de driehoek. Dit ontmoetingspunt wordt een knooppunt (junction) genoemd. De gehele structuur rust op het feit dat deze snaren op hun specifieke paden blijven en niet per ongeluk naar een andere kleur springen of een afkorting door de driehoek nemen.

De uitdaging ontstaat tijdens het proces van het controleren op fouten. Om te waarborgen dat de qubits correct werken, moet de computer ze herhaaldelijk meten. Deze meting gebeurt door een hulpqubit, een ancilla genoemd, in een specifieke sequentie te verbinden met de dataqubits. Als de hulpqubit een fout maakt in het begin van deze sequentie, kan die fout zich "haken" aan de dataqubits die hij nog moet raken, waardoor een cluster van fouten tegelijkertijd verschijnt. In het verleden geloofden onderzoekers dat ze, door de volgorde van de verbindingen voor elke kleur zorgvuldig te ordenen, deze haken konden voorkomen dat ze afkortingen creëerden die de code zouden breken. Een recent artikel door Kishony en Fowler stelde een dergelijk schema voor, waarin werd betoogd dat het alle gevaarlijke afkortingen in het midden van de code elimineerde, waardoor alleen de randen kwetsbaar bleven.

Issa en Martonosi namen een nauwkeurigere blik op dit voorgestelde schema en vonden een fout in de logica. Ze realiseerden zich dat de vorige analyse alleen zocht naar fouten die een enkele gekleurde snaar verkorten. Echter, zij identificeerden een nieuw type fout dat anders werkt. Op het knooppunt waar de rode, groene en blauwe snaren samenkomen, bevindt zich een specifieke arrangement van dataqubits. Als een haakfout optreedt op twee specifieke qubits bij dit knooppunt, verkort het niet slechts één snaar. In plaats daarvan creëert het een afkorting die twee verschillende gekleurde snaren tegelijkertijd verbindt. Omdat deze fout twee kleuren tegelijk overbrugt, voldoet het niet aan de definitie van de fouten met een enkele kleur waar het vorige schema op was ontworpen om te blokkeren. Het is als een brug die twee verschillende rivieren bij hun samenvloeiing verbindt; het verkort niet het pad van de rivieren afzonderlijk, maar het staat water toe om tussen hen te stromen op een manier die de beoogde route omzeilt.

De onderzoekers verifieerden deze bevinding door middel van gedetailleerde simulaties op codes van verschillende groottes, specifiek afstanden van 7, 9 en 11. In elk geval ontdekten ze dat op bijna elke tegel die geen hoektegel is, het voorgestelde schema een situatie creëerde waarin een enkele haakfout, gecombineerd met een paar andere kleine fouten, een logische fout kon produceren die het systeem niet kon detecteren. Dit betekent dat het vermogen van de code om informatie te beschermen met één stap is verminderd, waardoor het minder betrouwbaar is dan de oorspronkelijke bewering deed vermoeden. De studie sluit expliciet de mogelijkheid uit dat het schema veilig is voor het midden van de code zonder verdere wijzigingen. De auteurs tonen aan dat men, om de volledige veiligheid van de code te herstellen, extra beschermingsmechanismen, zoals flag-qubits, aan de tegels in het midden van de driehoek zou moeten toevoegen, en niet alleen aan de tegels op de grens.

Ondanks deze tegenslag is het nieuwe schema geen totale mislukking. De onderzoekers leggen uit dat de reden dat de code nog steeds beter presteert dan oudere methoden is dat deze knooppuntfouten op een specifieke manier zeldzaam zijn. Hoewel een fout met een enkele kleur theoretisch zich langs een lange reeks dataqubits kan ophopen, kan een knooppuntfout alleen optreden op het ene punt waar de drie snaren samenkomen. Omdat een enkel stuk informatie ten hoogste één zodanig ontmoetingspunt heeft, kunnen deze fouten zich niet op hetzelfde pad ophopen om een catastrofale fout te veroorzaken. Deze beperking verklaart waarom de prestaties van de code verbeterden van een zeer laag niveau naar een veel hoger niveau, ook al bereikte het niet het perfecte veiligheidsniveau waar oorspronkelijk op werd gehoopt. De resterende kloof in veiligheid wordt veroorzaakt door een ander type fout nabij de randen, wat de onderzoekers als een apart probleem beschouwen.

Het werk van Issa en Martonosi dient als een cruciale correctie voor het vakgebied, waarbij wordt benadrukt hoe complex deze systemen zijn en hoe gemakkelijk een subtiel over het hoofd gezien detail een deur voor fouten kan openen. Door de knooppunt-haakfout te identificeren, bieden ze een duidelijk doelwit voor toekomstige verbeteringen. De studie beweert niet het probleem van foutcorrectie te hebben opgelost, maar het verduidelijkt precies waar de huidige oplossing tekortschiet. Het suggereert dat de weg naar een betrouwbare kwantumcomputer een meer uitgebreide aanpak vereist voor het beschermen van de code, waarbij ervoor wordt gezorgd dat elk deel van het systeem, van de randen tot het diepste centrum, beschermd is tegen deze specifieke, verraderlijke afkortingen. De bevindingen herinneren de wetenschappelijke gemeenschap eraan dat in de ingewikkelde wereld van kwantumfoutcorrectie, het begrijpen van de geometrie van hoe informatie stroomt, net zo belangrijk is als de hardware zelf.