Kvantdatorsimulator

Grunderna: hur fungerar det?

Från program till fysisk kvantbit

En verklig kvantdator är mer än ett chip. Klassisk styrelektronik översätter kretsen till precisa pulser. I exemplet formar kyl-, repump-, kvantbits- och avläsningslasrar signalerna på ett optiskt bord och leder dem in i en skärmad vakuumkammare. Där ändrar och mäter de kvantbitens tillstånd, och mätresultatet återvänder sedan till den klassiska datorn.

Kvantbitar och bastillstånd

En klassisk bit är antingen 0 eller 1. En kvantbit kan dessutom finnas i en superposition av de två bastillstånden |0⟩ och |1⟩. Med flera kvantbitar skrivs alla bastillstånd som en bitsträng, till exempel |10⟩ för 2 kvantbitar, där q0 i denna simulator alltid är den mest signifikanta (vänstra) biten.

Superposition

En kvantbit i superposition innehåller samtidigt komponenter av flera bastillstånd. Komponenterna beskrivs som komplexa amplituder. Kvadraten av en amplituds absolutbelopp ger sannolikheten att få motsvarande tillstånd vid en mätning.

Bloch-sfären

En enskild kvantbits tillstånd kan visas som en pil i en sfär: nordpolen motsvarar |0⟩, sydpolen |1⟩, och alla punkter på ekvatorn är likformigt viktade superpositioner. Fasen avgör åt vilket håll längs ekvatorn pilen pekar. Rotationsgrindarna rx, ry, och rz roterar pilen runt respektive axel, medan fasgrindar som S och T roterar den runt Z-axeln. För sammanflätade kvantbitar krymper pilen mot sfärens mitt. Den enskilda kvantbiten har då inte längre ett eget rent tillstånd, så sammanflätningen blir bokstavligen synlig.

Mätning och shots

measureAll() mäter alla kvantbitar samtidigt och avslutar kretsen. Eftersom en enskild mätning endast ger ett slumpmässigt resultat mäts kretsen konceptuellt ett antal ”shots” med run({ shots }), så att sannolikhetsfördelningen visas som ett histogram. De exakta sannolikheterna beräknas dessutom direkt från tillståndsvektorn, oberoende av slumpen i mätningarna.

Hadamard-grinden

Hadamard-grinden h(q) för en kvantbit från ett bestämt tillstånd (|0⟩ eller |1⟩) till en likformigt viktad superposition av |0⟩ och |1⟩ , alltså ungefär 50 % / 50 % vid mätning.

Fasgrindar: S och T

Grindarna s(q) och t(q) ändrar inte mätsannolikheterna för en enskild kvantbit, utan roterar endast fasen för |1⟩ -amplituden: S med 90° och T med 45°. Effekten syns endast i kombination med superposition. Mellan två Hadamard-grindar avgör fasen hur amplituderna kombineras eller tar ut varandra (interferens). Dagger-varianterna sdg(q) och tdg(q) roterar exakt åt motsatt håll och upphäver S respektive T. Regeln är: två T bildar en S och två S bildar en Z.

CNOT och villkorlig sammanflätning

CNOT-grinden cnot(control, target) vänder målkvantbiten exakt när kontrollkvantbiten är i tillstånd |1⟩. Om kontrollkvantbiten först är i superposition kan det skapa sammanflätning. De två kvantbitarna kan då inte längre beskrivas oberoende av varandra, som i exemplet med Bell-tillståndet. Om kontrollkvantbiten i stället är i ett bestämt bastillstånd utför CNOT endast en villkorlig bitvändning utan sammanflätning. Därför skapar inte varje CNOT automatiskt sammanflätning.

CZ: CNOT:s symmetriska släkting

CZ-grinden cz(a, b) byter tecken på amplituden exakt när båda kvantbitarna är |1⟩. Till skillnad från CNOT finns ingen kontroll- eller målkvantbit. Grinden verkar likadant på båda kvantbitarna och ritas därför som två sammanbundna punkter i diagrammet. CZ och CNOT kan omvandlas till varandra: en CNOT är en CZ vars målkvantbit passerar genom en Hadamard-grind före och efter. CZ är en central byggsten i många algoritmer, till exempel Grover-sökning.

GHZ-tillstånd: sammanflätning i en trio

GHZ-tillståndet (uppkallat efter Greenberger, Horne och Zeilinger) utvidgar principen för Bell-tillstånd till tre kvantbitar. En Hadamard-grind och två CNOT sammanflätar alla tre så att mätningen endast ger |000⟩ eller |111⟩ , aldrig blandade bitsträngar. Ingen kvantbit har längre ett eget tillstånd, utan informationen finns uteslutande i den gemensamma korrelationen.

Deutsch-algoritmen: den minsta kvantfördelen

Deutsch-algoritmen besvarar med en enda utvärdering av ett okänt orakel en fråga som en klassisk dator behöver två utvärderingar för: är funktionen konstant eller balanserad? Knepet är att skicka indata genom oraklet i superposition. Tack vare interferens kodas svaret sedan entydigt i indatakvantbiten. Principen bakom detta (phase kickback) är central i nästan alla kvantalgoritmer.

Grover-sökning: förstärk amplituder

Grover-sökning hittar en markerad post i en osorterad mängd med betydligt färre frågor än vad som krävs klassiskt. Ett orakel markerar det sökta tillståndet med en fasvändning (här via en CZ-grind), varefter diffusionsoperatorn förstärker den markerade amplituden på de övrigas bekostnad. Med 2 kvantbitar räcker en enda iteration för att mäta träffen med 100 % sannolikhet.

Reversibel addition: från quantum.add() till en krets

Programkodsredigeraren ovan översätter quantum.add({ a, b }) till en krets av X-, CNOT- och CCNOT-grindar (Toffoli) som återskapar klassisk addition på ett helt reversibelt sätt. Varje grind kan upphävas exakt eftersom ingen information kastas bort. En CCNOT-grind (ccnot(c1, c2, target)) vänder målkvantbiten endast när båda kontrollkvantbitarna är |1⟩ . Det räcker som byggsten för att återskapa vilken klassisk krets som helst reversibelt, inklusive en fulladderare med minnessiffra. Indata A och B initieras först som bestämda bastillstånd (ingen superposition) med X-grindar. Eftersom hela kretsen då endast passerar genom bestämda tillstånd i stället för superpositioner ger den avslutande mätningen exakt ett resultat med 100 % sannolikhet: den klassiskt korrekta summan. Därför ger quantum.add() ett deterministiskt resultat trots kvantsimuleringen, i stället för flera möjliga tillstånd med sannolikheter under 100 %.

Subtraktion: addition baklänges

Eftersom varje grind i en kvantkrets är exakt inverterbar kan hela additionskretsen köras baklänges, och additionen blir en subtraktion: quantum.subtract({ a, b }) använder exakt adderarens grindar i omvänd ordning och beräknar därmed a − b. Det är ingen gimmick utan grundprincipen för reversibel beräkning: inget beräkningssteg förstör information och varje steg kan göras ogjort. I den här versionen krävs a ≥ b så att resultatet inte blir negativt.

Multiplikation: quantum.multiply()

Multiplikationen byggs av exakt samma reversibla byggstenar som additionen. Enligt uppställningsmetoden adderas faktor a flera gånger i förskjutna positioner som motsvarar de satta bitarna i faktor b. Varje deladdition är samma reversibla ripple-carry-adderare, och minnessiffran förs varje gång till nästa produktbit. Eftersom resultatregistret växer med produkten begränsas faktorerna här till 3 bitar (0–7). Först då ryms faktor, produkt och minneskvantbit tillsammans inom simulatorns 10 kvantbitar.

Division: quantum.divide()

Division använder också endast reversibla byggstenar: quantum.divide({ a, b }) utför liggande stolen med förskjutna, reversibla subtraktioner av divisorn från restregistret. Resultatet är kvoten och resten (a = quotient · b + remainder). Eftersom dividend, divisor, kvot och en lånekvantbit tillsammans måste rymmas inom 10 kvantbitar är division den mest begränsade operationen: bits(a) + bits(b) + bits(a÷b) + 1 ≤ 10 måste gälla, och divisorn b måste vara ≥ 1 (ingen division med noll). Om indata inte ryms inom budgeten visar redigeraren ett meddelande i stället för att beräkna.

Verklig slump: quantum.random()

Klassiska datorer kan inte skapa verklig slump. Deras ”slumptal” kommer från deterministiska algoritmer (pseudoslump). En kvantdator kan: quantum.random({ bits }) försätter varje bit i en 50/50-superposition med en Hadamard-grind, och först mätningen avgör – i grunden oförutsägbart – vilket värde som kommer ut. På verklig kvantmaskinvara är detta fysiskt sann slump. Simulatorn efterliknar den med webbläsarens pseudoslump.

Simulator jämfört med verklig kvantmaskinvara

Simulatorn beräknar tillståndet exakt med klassisk flyttalsaritmetik i webbläsaren. Det är bara möjligt eftersom den uteslutande behandlar mycket små kretsar med högst 10 kvantbitar. Verkliga kvantdatorer använder fysiska kvantbitar, är felkänsliga (dekoherens och brus) och visar sin fördel först med mycket större kretsar som i praktiken inte längre kan simuleras klassiskt. Verktyget är avsett för lärande och är ingen verklig kvantprocessor.