Quantumcomputers beloven problemen op te lossen die klassieke machines duizenden jaren zouden kosten, maar ze zijn ongelooflijk fragiel. De kleinste verstoring door warmte of trilling kan de informatie die ze bevatten verstoren, waardoor berekeningen mislukken. Om dit te overwinnen, bouwen wetenschappers fouttolerante quantumcomputers, die niet vertrouwen op perfecte, foutvrije onderdelen. In plaats daarvan groeperen ze veel fysieke deeltjes samen om een enkele, stabiele "logische" eenheid van informatie te vormen. Als één deeltje in de groep een foutje maakt, kunnen de anderen de fout detecteren en herstellen zonder de data te verliezen. Dit proces, bekend als quantumfoutcorrectie, is de basis van de toekomstige machine, maar het komt met een hoge prijs: een enkele nuttige berekening kan miljoenen fysieke deeltjes vereisen die in unison werken.

De uitdaging is niet alleen het bouwen van de hardware, maar ook het schrijven van de software om deze te besturen. De huidige tools voor het programmeren van quantumcomputers zijn ontworpen voor de huidige ruisgevoelige, kleinschalige apparaten. Ze begrijpen de complexe regels niet die nodig zijn om foutcorrectie te beheren, zoals hoe men de "syndromen" moet volgen die een fout signaleren of hoe men speciale bronnen moet voorbereiden die nodig zijn voor moeilijke berekeningen. Zonder een softwaresysteem dat de taal van foutcorrectie spreekt, kunnen ingenieurs een hoogwaardig idee niet betrouwbaar vertalen naar een fysiek circuit dat een echte machine kan uitvoeren. Een team van onderzoekers bij Oak Ridge National Laboratory heeft dit gat gedicht door een nieuwe compiler te creëren, een stuk software dat fungeert als een vertaler tussen menselijke logica en de rigide, foutgecorrigeerde wereld van een toekomstige quantumcomputer.

De onderzoekers bouwden een systeem genaamd FTQC, wat staat voor Fault-Tolerant Quantum Computing. Denk aan een compiler als een vertaler die een programma geschreven in een hogere programmeertaal neemt en dit omzet in de specifieke instructies die een machine begrijpt. In de quantumwereld is dit moeilijk omdat de machine niet alleen een programma uitvoert; de machine moet zichzelf constant monitoren op fouten en deze in realtime corrigeren. Het nieuwe systeem introduceert een manier om deze foutgecorrigeerde eenheden direct in de code te beschrijven. In plaats van een logische qubit als een eenvoudige variabele te behandelen, geeft de software het een specifieke identiteit die ook de regels voor foutcorrectie bevat. Dit stelt de compiler in staat om bij elke stap te controleren of de uitgevoerde operaties geldig zijn voor dat specifieke type foutbescherming. Als een programmeur probeert twee verschillende soorten foutcorrectie te mengen die niet samenwerken, stopt de compiler en geeft een foutmelding voordat de code de machine überhaupt bereikt.

Om de complexiteit te beheersen, ontwierpen de onderzoekers het systeem met twee duidelijke niveaus. Het bovenste niveau behandelt de logische instructies, de hoogwaardige wiskunde en logica die een wetenschapper wil uitvoeren. Het onderste niveau behandelt de fysieke realiteit, de individuele deeltjes en de specifieke poorten die hen manipuleren. Een speciaal proces in het midden vertaalt de logische instructies naar de fysieke instructies, waarbij één enkele logische opdracht wordt uitgebreid naar een groot blok fysieke operaties. Dit ontwerp zorgt ervoor dat hetzelfde logische programma naar verschillende soorten hardware kan worden verzonden zonder dat het opnieuw geschreven hoeft te worden. Het systeem bevat ook een ingebouwde rekenmachine die schat hoeveel fysieke deeltjes er nodig zullen zijn voor een bepaalde taak. Dit is cruciaal omdat de kosten van foutcorrectie hoog zijn; een eenvoudige berekening kan een fabriek aan extra deeltjes vereisen om de hoofddata veilig te houden.

Het team testte hun systeem met verschillende standaard quantumalgoritmen, waaronder een methode voor het doorzoeken van gegevens en een techniek voor het analyseren van de eigenschappen van moleculen. Ze voerden deze tests uit op een simulator om te zien hoe de software de vertaling en de bronnenverdeling afhandelde. De resultaten lieten zien dat de compiler erin slaagde om logische programma's succesvol om te zetten in fysieke circuits voor verschillende soorten foutcorrectiecodes, waaronder de Steane-code en de surface code. Een van de meest onthullende bevindingen kwam voort uit het analyseren van een drie-qubit berekening die bekend staat als een Quantum Fourier Transform. De compiler bepaalde dat om deze berekening met foutcorrectie uit te voeren, het systeem een "magic state factory" nodig zou hebben — een specifiek blok aan bronnen om speciale toestanden voor te bereiden die nodig zijn voor de wiskunde. Deze fabriek vereiste vijf keer zoveel fysieke deeltjes als het volledige gecodeerde circuit zelf. Dit benadrukt een verborgen kostenpost in de fouttolerante computing: de middelen die nodig zijn om het systeem te onderhouden, overstijgen vaak de middelen die nodig zijn voor de berekening zelf.

Naast simulaties brachten de onderzoekers hun werk naar echte hardware. Ze richtten zich op een 20-qubit supergeleidende quantumcomputer bij het Oak Ridge National Laboratory. Ze gebruikten hun compiler om een eenvoudig logisch circuit te vertalen naar de native instructies van de machine. Omdat de machine te klein is om een volledige foutgecorrigeerde berekening uit te voeren, gebruikten ze de compiler om het fysieke circuit te genereren en pasten ze na de uitvoering een klassiek decodeerproces toe op de resultaten. De resultaten waren veelbelovend: door de foutcorrectie-informatie te gebruiken die door de compiler werd gegenereerd, waren ze erin geslaagd de logische uitleesfout met een factor 3,3 te verminderen. Dit betekent dat het uiteindelijke antwoord aanzienlijk nauwkeuriger was dan de ruwe data van de machine, wat bewijst dat de output van de compiler succesvol de fysieke hardware kon bereiken en de kwaliteit van de resultaten kon verbeteren.

Het werk beweert niet het probleem van het bouwen van een fouttolerante computer te hebben opgelost. De experimenten waren beperkt in omvang en hebben niet de volledige drempel aangetoond waarbij foutcorrectie perfect effectief wordt. De simulaties gebruikten vereenvoudigde modellen voor bepaalde complexe operaties, en de hardwaretests waren proof-of-concept-runs in plaats van volledige demonstraties op grote schaal. Echter, het systeem biedt een praktisch fundament voor de volgende fase van ontwikkeling. Door de regels van foutcorrectie zichtbaar en beheersbaar te maken binnen de software, hebben de onderzoekers een hulpmiddel gecreëerd waarmee ingenieurs hun ontwerpen kunnen inspecteren, verifiëren en optimaliseren voordat ze worden gebouwd. Deze helderheid is essentieel voor de overgang van theoretische ideeën naar de massieve, complexe systemen die vereist zijn voor de volgende generatie quantumcomputing.