Kenmerken van kwantumcomputers

De kracht van een quantumcomputer wordt gemeten in qubits, de basis eenheid van meting in een quantumcomputer. Bron.

Ik maak een facepalm na elke keer dat ik zo'n zin lees. Dit heeft nergens goed geleid, mijn zicht begint te verslechteren; binnenkort moet ik naar Meklon.

Ik denk dat het tijd is om de belangrijkste parameters van een quantumcomputer systematisch te ordenen. Er zijn er verschillende:

1. Aantal qubits
2. Coherentie-tijd (decoherentie tijd)
3. Foutenniveau
4. Processorarchitectuur
5. Prijs, beschikbaarheid, onderhoudsvoorwaarden, afschrijvingsperiode, programmeertools, enz.

Aantal qubits

Dit is duidelijk, hoe meer, hoe beter. In de praktijk moet je echter betalen voor qubits, en idealiter moet je precies het aantal qubits kopen dat nodig is om de taak uit te voeren. Voor de ontwikkelaar van exclusieve gokkasten is één qubit per machine voldoende (voor het genereren van willekeurige getallen). Voor ‘bruteforcing’ RSA-2048 zijn minimaal 2048 qubits nodig.

De meest gepromote quantumalgoritmen zijn die van Grover en Shor. Grover maakt het mogelijk om hashes te 'hacken'. Voor de ondergang van Bitcoin zijn computers met minimaal 256 qubits aan boord nodig (je kunt spelen met de moeilijkheidsgraad van Bitcoin, maar laten we bij dit mooie ronde getal blijven). Shor maakt het mogelijk om getallen te factoriseren. Voor het factoriseren van een getal met n binaire cijfers zijn minimaal n qubits nodig.

De huidige maximum: 50 qubits (al 72?). En eigenlijk is 50 qubits de limiet. De limiet van de simulatie van een quantumcomputer. In theorie kunnen we elk aantal qubits simuleren op klassieke computers. In de praktijk vereist het toevoegen van één qubit aan de simulatie een verdubbeling van de klassieke computers. Voeg hier de geruchten over het verdubbelen van qubits elk jaar aan toe, en stel jezelf de vraag: hoe debug je algoritmen voor 25651210242048 qubits? Er is geen simulator, je kunt geen breakpoint zetten op een quantumprocessor.

Coherentie-tijd (decoherentie tijd)

Coherentie en consistentie zijn niet hetzelfde. Ik vergelijk consistentie liever met de regeneratie van RAM-geheugen. Op een RAM-module bevinden zich miljarden cellen, elk met een lading die nul of één is. Deze lading heeft een bijzonder eigenschap: hij lekt weg. In eerste instantie wordt een 'één'-cel een cel van 0.99, dan 0.98, enzovoorts. Evenzo accumuleert de nulwaarde 0.01, 0.02, 0.03… Deze lading moet worden vernieuwd, 'geregenereerd'. Alles onder de helft wordt teruggebracht naar nul, de rest wordt verhoogd tot één.

Kwantumprocessoren kunnen niet regenereren. Dit betekent dat er voor alle berekeningen één cyclus beschikbaar is, tot de eerste 'lekkende' qubit. De tijd tot de eerste 'lekkage' wordt de decoherentie tijd genoemd. Coherentie is de toestand waarin qubits nog niet 'gelekt' zijn. Hier Er zijn iets volwassenere verklaringen beschikbaar.

Decoherentie hangt samen met het aantal qubits: hoe meer qubits, hoe moeilijker het is om coherentie te behouden. Aan de andere kant, bij een groot aantal qubits kan een deel van hen worden gebruikt voor het corrigeren van fouten die verband houden met decoherentie. Hieruit volgt, dat het aantal qubits op zich niets oplost. Je kunt het aantal qubits verdubbelen, maar 90% daarvan gebruiken voor het vastleggen van decoherentie.

Hier ontstaat ongeveer het begrip van de logische qubit. Grofweg gezegd, als je een processor met 100 qubits hebt, maar 40 daarvan bestemd zijn voor het vastleggen van decoherentie — dan houd je 60 logische qubits over. Diegenen waarop je je algoritme uitvoert. Het concept van logische qubits is momenteel eerder theoretisch, ik heb persoonlijk niets gehoord over praktische implementaties.

Fouten en hun correctie

Nog een probleem voor kwantumprocessoren. Als je een qubit omdraait, is er een kans van 2% dat de operatie eindigt in een fout. Als je 2 qubits verstrengelt, bereikt de foutkans 8%. Neem een nummer van 256 bits, hash het met SHA-256, tel het aantal bewerkingen en bereken de kans om AL deze bewerkingen foutloos uit te voeren.

Wiskundigen bieden een oplossing: foutcorrectie. Er zijn algoritmen. De implementatie van de verstrengeling van 2 logische qubits vereist 100.000 fysieke qubits. De bitcoin-apocalyps zal niet snel komen.

Processorarchitectuur

Strikt genomen bestaan er geen kwantumcomputers. Er zijn alleen kwantumprocessoren. Waarom heb je ram nodig als de tijd om te werken in milliseconden wordt beperkt? Ik programmeer in Q#, maar dat is een high-level taal. Ik heb 15 qubits toegewezen en doe ermee wat ik wil. Als ik wil, verwarde ik de eerste qubit met de tiende. Als ik wil, verwarde ik de eerste zes.

Op een echte processor is er die vrijheid niet. Ik vroeg om de eerste qubit met de 15e te verknopen — de compiler genereert 26 extra operaties. Als je geluk hebt. Als je geen geluk hebt, genereert hij er honderd. Het probleem is dat een qubit alleen met buren kan verknopen. Meer dan 6 buren voor een qubit heb ik nog nooit gezien. In principe zijn er optimaliserende kwantumprogrammacompilers, maar die zijn tot nu toe eerder theoretisch.

Elke processor heeft zijn eigen instructie set, en de verbindingen tussen qubits verschillen. In een ideale wereld hebben we willekeurige Rx, Ry, Rz, en hun combinaties, plus vrije verknoping van een dozijn eigenschappen, plus Swap: kijk naar de operatoren in Quirk. In werkelijkheid hebben we echter enkele paren qubits, en verknoping CNOT (q[0], q[1]) kost één operatie, terwijl CNOT(q[1], q[0]) al 7 kost. En de coherentie verdwijnt...

Prijs, beschikbaarheid, onderhoudsvoorwaarden, afschrijvingstijd, programmeertools...

De prijzen worden niet bekendgemaakt, de beschikbaarheid voor de gewone burger is bijna nul, de afschrijvingstijd is in de praktijk niet berekend, en de programmeertools zijn nog maar net in ontwikkeling. Documentatie is te vinden op arxiv.org.

Welke informatie moet er van experts worden gevraagd bij de lancering van een nieuwe kwantumcomputer?

Naast de bovenstaande lijst, vind ik de opties van PerlPower en Alter2:

Het zou fantastisch zijn als elk artikel over een nieuwe kwantumcomputer zou beginnen met twee eigenschappen — het aantal tegelijkertijd verweven qubits, en de tijd dat de qubits worden vastgehouden.

Of nog beter — met de uitvoeringstijd van de eenvoudigste benchmark, bijvoorbeeld het vinden van de priemfactoren van het getal 91.

Bron: habr.com