Kwantumcomputers worstelen voortdurend met fouten

Foutcorrectie kwantumcomputer

Voor foutcorrectie van een logische kwabit heb je negen fysieke kwabits nodig en twee hulpbits (afb: Quanta Magazine)

Kwantumbits zijn nogal instabiel. Dat betekent dat als je wat aan die dingen wil hebben dat je een manier moet zien te vinden om die fouten voortdurend te corrigeren. Daar wordt intussen volop aan gesleuteld.
In 1994 bewees Peter Shor, een wiskundige op het Bell-lab in New Jersey (VS), dat de kwantumcomputer in principe in staat is om sommige problemen aanzienlijk sneller op te lossen dan het ‘gewone’ digitale rekentuig. Alleen was toen de grote vraag: zou zo’n ding ooit gebouwd kunnen worden? Skeptici hadden er een hard hoofd in. De kwantumwereld was te ‘labiel’ (makkelijk te beïnvloeden door externe zaken).
Een jaar later had Shor een antwoord klaar. Klassieke foutcorrectie zou de afzonderlijke bits beïnvloeden en dus de operatie waar die computer mee bezig was. Hij bedacht een manier om fouten te ontdekken zonder de toestand van de kwantumbit te meten (waarmee je dat bit ‘ontkwantumt’). Dat is het begin geworden van een apart vak in het kwantumrekenen: de foutcorrectie. “We zullen nooit een kwantumcomputer hebben die echt grote problemen kan aanpakken zonder foutcorrectie”, zegt John Preskill van Caltech.

Het wordt nog lastiger. Het is één ding om zo’n methode te ontwikkelen, maar het is nog lastiger om die in een werkende kwantummachine te laten functioneren. Begin oktober kwamen bezoekers rond Chris Monroe van de universiteit van Maryland met een artikel dat een experiment beschrijft met ingrediënten van een foutcorrector zoals Shor bedoeld heeft (moet hebben?).

Hoe had Shor dat aangepakt? Hij zou gebruik gemaakt hebben van de ingewikkeldheid van de kwantummechanica en deed daar zijn voordeel mee. Zijn oplossing was herhaling. Maak van elke bit een kopie en vergelijk die kopieën regelmatig. Als er dan een fout is dan kan de fout hersteld worden en kan de computer doorgaan met zijn berekening.
Van dat idee uitgaand maakte Shor een kwantumversie. Hij gebruikte drie kwantumbits om een functionele kwantumbit foutloos te laten functioneren. Zijn kwantumherhalercode kon niet zo zijn als de klassieke versie. Het extra van een kwantumrekentuig komt van het feit dat een kwabit in superpositie kan verkeren, dat wil zeggen tegelijkertijd 0 en 1 kan zijn. Meting verstoort die superpositie dus kun je ook niet rechtstreeks controleren of er sprake is van een fout.

Hulpbits

Shor gebruikte twee ‘hulp’kwabits. De eerste werd vergeleken met de eerste en tweede echte kwabit, de andere met de tweede en derde echte. Zo kom je aan de weet welke van de drie echte kwabits in dezelfde toestand verkeren zonder die toestand zelf te beïnvloeden.
Deze code beschermt tegen het omklappen van een klassieke bit, maar kwabits hebben met meer foutbronnen te maken. Superpositie is de kracht en de zwakte van kwantumrekenen. Niet alleen de waarde van zo’n bit is belangrijk, ook de relatieve ‘fase’ tussen de kwabits doet er toe. Die ‘fase’ kun je zien als een golf. Als twee golven in fase zijn dan worden die gesynchroniseerd en versterken ze elkaar, als ze ‘botsen’ vernietigen ze elkaar geheel of gedeeltelijk (afhankelijk van de faseverschuiving).
Een kwantumalgoritme maakt daar gebruik van. Die creëert een situatie waarin het juiste antwoord versterkt zoals de in pas lopende golven. Het onjuiste antwoord wordt weggedrukt (elkaar ’tegenwerkende’ golven). Als de fout er echter voor zorgt dat de fase omklapt dan kan die uitdoving omslaan in versterking en dan zou de kwantumrekenaar het foute antwoord versterken.
Shor vond, ja het is een heel gedoe, dat je voor die fasefouten hetzelfde principe kon gebruiken als voor het omklappen van de bits. Elke kwabit bestaat uit drie bis, die gecontroleerd worden door twee hulpbits om te zien of de fase is omgeklapt. Hij combineerde de twee codes. Het resultaat was een code die een logische kwabit vertaalde in negen fysieke kwabits, die zowel de bit als de fase controleerden.

Bescherming

Die oplossing moest in principe een logische kwabit beschermen tegen het maken van fouten, maar wat als er iets mis was in de foutmetingen zelf? Dan zou zou je, ongewild, zelf een fout introduceren. Dat zou tot een stortvloed aan fouten kunnen leiden door de hele code heen. Shors code hield ook geen rekening met hoe een kwantumcomputer zou werken die was opgebouwd met zijn logische kwabits.
“We moeten op een of andere manier mee kunnen rekenen, zonder dat we de bescherming (tegen fouten; as) verliezen”, zegt Daniel Gottesman van de universiteit van Maryland. “Dat is niet vanzelfsprekend.”
Dus toen kwam Shor in 1996 met het begrip fouttolerantie. Een fouttolerant algoritme kan omgaan met fouten die door de omgeving, door verkeerde bewerkingen door kwabits en zelfs door de foutcorrectie zelf worden veroorzaakt, vooropgesteld dat de snelheid waarmee fouten ontstaan beneden een bepaalde limiet ligt.

De vorige maand kondigden Monroe en de zijnen aan dat ze een fouttolerante versie van Shors code hadden gebruikt, de Bacon-Shorcode, en daarmee aantoonden dat bijna alle middelen er waren die nodig zijn voor een volledig fouttolerante kwantumcomputer. Die zou dus in principe mogelijk zijn.

Ver weg

Voorlopig is die echter nog ver weg. Het voordeel van foutcorrectie zal pas zichtbaar worden als een kwantumcomputer over honderd logische kwabits beschikt, denkt Monroe. Dat betekent dat zo’n machine 1300 (ze gebruikten negen kwabits en vier hulpbits voor een logische bit) feitelijke kwabits nodig heeft. De grootste nu is de 127-bits-kwantumcomputer van IBM (als je de dingen van D Wave Systems niet als kwantumcomputers meerekent).

Bron: Quanta Magazine

Geef een antwoord

Het e-mailadres wordt niet gepubliceerd. Vereiste velden zijn gemarkeerd met *

Deze site gebruikt Akismet om spam te verminderen. Bekijk hoe je reactie-gegevens worden verwerkt.