Övning – Skapa olika superpositionstillstånd med Q#

  • 12 minuter

I de föregående lektionerna lärde du dig om superposition och dirac-notation. Det räcker med teori för tillfället! Nu ska vi skriva lite kod för att utforska superposition i Q#.

I den här lektionen skapar du kvantsuperpositionstillstånd i Q# och utforskar sannolikhetens roll i mätresultat. Du använder DumpMachine också funktionen i Q# för att undersöka hur tillståndet för ett system ändras under en kvantberäkning.

Skapa en ny Q#-fil

  1. Öppna Visual Studio Code (VS Code).
  2. Öppna menyn Arkiv och välj sedan Ny textfil för att skapa en ny fil.
  3. Spara filen som Main.qs.

Kom igång med superposition

Vi börjar med ett enkelt Q#-program som använder en kvantbit i ett superpositionstillstånd för att generera ett slumpmässigt bitvärde, 0 eller 1. I vår kod använder DumpMachine vi funktionen för att se qubitens tillstånd vid olika tidpunkter i programmet.

  1. Kopiera och klistra in följande kod i Main.qs-filen :

    import Std.Diagnostics.*;

operation Main() : Result {
    use q = Qubit();
    Message("Initialized qubit:");
    DumpMachine(); // First dump
    Message(" ");
    H(q);
    Message("Qubit after applying H:");
    DumpMachine(); // Second dump
    Message(" ");
    let randomBit = M(q);
    Message("Qubit after the measurement:");
    DumpMachine(); // Third dump
    Message(" ");
    Reset(q);
    Message("Qubit after resetting:");
    DumpMachine(); // Fourth dump
    Message(" ");
    return randomBit;
}

  2. Om du vill köra programmet på den inbyggda simulatorn väljer du kör kodlinsen Main ovanför åtgärden eller trycker på Ctrl + F5. Dina utdata visas i felsökningskonsolen.

  3. Granska felsökningskonsolen för att hitta resultatet av mätningen, antingen Zero eller One.

Funktionen DumpMachine skapar en tabell med information som beskriver kvantsystemets tillstånd, vilket i det här fallet är en enda kvantbit. Informationen från DumpMachine inkluderar sannolikhetssamplituden, mätsannolikheten och fasen i radianer för varje bastillstånd.

Koden anropar DumpMachine funktionen fyra gånger:

  • När du har allokerat kvantbiten
  • När du har placerat kvantbiten i ett superpositionstillstånd
  • När du har mätt kvantbitens tillstånd
  • När du har återställt kvantbiten

Nu ska vi undersöka utdata från varje anrop till DumpMachine:

  • Initierad qubit: När du allokerar en kvantbit med use-instruktionen börjar kvantbiten alltid i tillståndet $|0\rvinkel$.

    Initialized qubit:

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
   |0⟩ |  1.0000+0.0000𝑖 |   100.0000% |   0.0000

  • Qubit efter att ha tillämpat H: När du har tillämpat H operationen är kvantbiten i ett jämlikt superpositionstillstånd, $|\psi\rangle=\frac1{\sqrt2} |0\rangle + \frac1{\sqrt2} |1\rangle$.

    Qubit after applying H:

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
   |0⟩ |  0.7071+0.0000𝑖 |    50.0000% |   0.0000
   |1⟩ |  0.7071+0.0000𝑖 |    50.0000% |   0.0000

  • Qubit efter mätningen: När du har mätt kvantbiten är resultatet antingen Zero eller One, och kvantbiten är helt i det tillstånd som du har mätt.

    Qubit after the measurement:

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
   |1⟩ |  1.0000+0.0000𝑖 |   100.0000% |   0.0000

    Kommentar

    Dina utdata från DumpMachine efter mätningen kan skilja sig från exempelutdata eftersom du har 50% chans att mäta varje tillstånd. Sannolikheten för utfallen är deterministisk, men resultatet av en enskild mätning är inte det.

  • Qubit efter återställning: Åtgärden Reset återställer kvantbiten till tillståndet $|0\rangle$ så att den kan användas igen för framtida beräkningar.

    Qubit after resetting:

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
   |0⟩ |  1.0000+0.0000𝑖 |   100.0000% |   0.0000

Utforska andra superpositionstillstånd

Nu när du vet hur du inspekterar tillståndet för ett qubitsystem med DumpMachineska vi utforska andra åtgärder som placerar systemet i olika typer av superpositionstillstånd.

Den aktuella slumpmässiga bitgeneratorn producerar antingen Zero eller One med en sannolikhet på 50%. I nästa exempel är sannolikheterna inte lika med.

Förskjuten slumpmässig bit-generator

Anta att du vill skapa en slumpmässig bitgenerator som är skev, vilket innebär att sannolikheten för att få Zero skiljer sig från sannolikheten att få One.

Du vill till exempel ha utfallet Zero med sannolikheten $P$ och resultatet One med sannolikheten $1 – P$. Här är ett giltigt qubit-tillstånd som genererar en sådan slumpmässig bitgenerator:

$$|\psi\rangle=\sqrt{P}|0\rangle+\sqrt{1 - P}|1\rangle$$

För det här tillståndet $|\psi\rangle$, $\alpha=\sqrt{P}$ och $\beta=\sqrt{1 – P}$ är sannolikhetssamplituderna för bastillstånden $|0\rangle$ respektive $|1\rangle$.

För att få det här tillståndet kan du sekventiellt tillämpa operatorn $R_y(2\cos^{-1}\sqrt{P})$ på en qubit som börjar i tillståndet $|0\rangle$. För att uppnå det här resultatet i Q#, använd Ry från standardbiblioteket.

Dricks

För att lära dig mer om matematiken bakom enkvantsbitsoperationer kan du kolla in självstudienSingle-Qubit Gates i Quantum Katas.

Följ dessa steg för att skapa ett skevt superpositionstillstånd i Q#:

  1. Ersätt all kod i Main.qs med följande exempel och spara sedan filen. I det här exemplet väljs $\alpha$ som cirka $\frac13$.

    import Std.Diagnostics.*;
import Std.Math.*;

operation Main() : Result {
    use q = Qubit();
    let P = 0.333333; // P is 1/3
    Ry(2.0 * ArcCos(Sqrt(P)), q);
    Message("The qubit is in the desired state.");
    DumpMachine(); // Dump the state of the qubit 
    Message("Your skewed random bit is:");
    let skewedrandomBit = M(q);
    Reset(q);
    return skewedrandomBit;
}

  2. Om du vill köra programmet på den inbyggda simulatorn väljer du kör kodlinsen Main ovanför åtgärden eller trycker på Ctrl + F5. Dina utdata visas i felsökningskonsolen.

  3. Granska utdata från DumpMachine och resultatet av mätningen. Utdata liknar till exempel följande:

    The qubit is in the desired state.

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
   |0⟩ |  0.5773+0.0000𝑖 |    33.3333% |   0.0000
   |1⟩ |  0.8165+0.0000𝑖 |    66.6667% |   0.0000

Your skewed random bit is:

One

Observera att sannolikheten för ett Zero mätresultat är cirka 33,33% och sannolikheten för ett One resultat är cirka 66,67%. Den här slumpmässiga bitgeneratorn är skev mot One.

Kommentar

Mätresultatets utdata kan skilja sig från exempelutdata eftersom den slumpmässiga bitgeneratorn är probabilistisk. Sannolikheten för utfallen är deterministisk, men resultatet av en enskild mätning är inte det.

Superposition för flera qubitsar

Hittills har vi bara övervägt system med en enda qubit. Men en bra kvantdator behöver många kvantbitar för att utföra användbara beräkningar. Hur fungerar kvanttillstånd och superposition när vårt system har mer än en kvantbit?

Tänk dig till exempel ett system med tre kvantbitar. Varje qubit kan ha värdet 0 eller 1 när du mäter dem, så det finns åtta möjliga tillstånd som du kan hitta systemet i:

$$|000\rvinkel,|001\rvinkel,|010\rvinkel,|011\rvinkel,|100\rvinkel,|101\rvinkel, |110\rvinkel,|111\rvinkel $$

Det finns åtta möjliga tillstånd för det här systemet eftersom varje kvantbit oberoende kan vara antingen ett 0- eller 1-tillstånd när vi utför en mätning. I allmänhet är antalet möjliga tillstånd lika med $2^n$, där $n$ är antalet kvantbitar.

Precis som med en enda qubit representeras ett godtyckligt superpositionstillstånd för 3-qubit-systemet som en viktad summa av dessa åtta tillstånd, där vikterna är sannolikhetsamplituderna:

$$|\psi\rangle=\alpha_0|000\rangle+\alpha_1|001\rangle+\alpha_2|010\rangle+\alpha_3|011\\rangle+\alpha_4|100\rangle+\alpha_5|101\rangle+\alpha_6 |110\rangle+\alpha_7|111\rangle$$

Amplituderna $\alpha_i$ är återigen komplexa tal som uppfyller villkoret $\sum\limits_{i=0}^{i=7}|\alpha_i|^2=1$.

Du kan till exempel placera kvantbitar i en enhetlig superposition genom att tillämpa på H varje qubit. Du kan sedan använda den här enhetliga superpositionen för att skapa en kvantgenerator för slumptal som genererar tre bitars tal i stället för enbitsnummer:

Grundtillstånd Antal
$\ket{000}$ 0
$\ket{001}$ 4
$\ket{010}$ 2
$\ket{011}$ 6
$\ket{100}$ 1
$\ket{101}$ 5
$\ket{110}$ 3
$\ket{111}$ 7

Kommentar

Standardsättet för att skriva bitsträngar är att ha den minsta siffran till höger och den största siffran till vänster, precis som med vanliga decimaltal. I Q# (och många andra kvantprogrammeringsspråk) är ordningen omvänd så att den minsta siffran finns till vänster och den största siffran finns till höger. DumpMachine Eftersom funktionen visar kvanttillstånd i standardordningen sorteras inte de decimaltal som tillstånden motsvarar sekventiellt från 0 till $n-1$.

Följ dessa steg för att skapa den här typen av slumptalsgenerator:

  1. Ersätt koden i Main.qs med följande exempel och spara sedan filen:

    import Std.Diagnostics.*;
import Std.Convert.*;

operation Main() : Int {
    use qubits = Qubit[3];
    ApplyToEach(H, qubits);
    Message("The qubit register in a uniform superposition: ");
    DumpMachine();
    let result = MeasureEachZ(qubits);
    Message("Measuring the qubits collapses the superposition to a basis state.");
    DumpMachine();
    ResetAll(qubits);
    return ResultArrayAsInt(result);
}

  2. Om du vill köra programmet på den inbyggda simulatorn väljer du kör kodlinsen Main ovanför åtgärden eller trycker på Ctrl + F5. Dina utdata visas i felsökningskonsolen.

  3. Granska utdata från DumpMachine och resultatet av mätningen. Utdata liknar till exempel följande:

    The qubit register in a uniform superposition: 

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
 |000⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |001⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |010⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |011⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |100⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |101⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |110⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |111⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000

Measuring the qubits collapses the superposition to a basis state.

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
 |011⟩ |  1.0000+0.0000𝑖 |   100.0000% |   0.0000

6

    Kommentar

    Dina utdata har förmodligen ett annat resultat än exempelutdata eftersom slumptalsgeneratorn är probabilistisk. Sannolikheten för utfallen är deterministisk, men resultatet av en enskild mätning är inte det.

Om du vill arbeta med flera kvantbitar har Q#-koden följande ändringar:

  • Variabeln qubits representerar nu en Qubit-matris som har längden tre.
  • Åtgärderna ApplyToEach och MeasureEachZ tillämpa kvantåtgärder på flera kvantbitar med bara en kodrad. Q#-biblioteken erbjuder många funktioner och åtgärder som förenklar kvantprogrammering åt dig.
  • Funktionen ResultArrayAsInt från Std.Convert biblioteket omvandlar den binära Result matrisen till ett decimaltal.

Utdata från DumpMachine visar att mätningsakten komprimerar superpositionstillståndet till ett av de åtta möjliga bastillstånden, precis som med en enda kvantbit. Om du till exempel får resultatet 6, innebär det att systemets tillstånd har kollapsat till $|011\rangle$.

Nu ska vi titta närmare på hur systemet ändras när vi mäter varje kvantbit. Föregående kod använde åtgärden MeasureEachZ för att mäta alla tre kvantbitar samtidigt. I stället ska vi använda en for loop för att mäta kvantbitarna en i taget och använda DumpMachine för att visa systemets tillstånd efter varje mätning.

  1. Ersätt koden i Main.qs med följande exempel och spara sedan filen:

    import Std.Diagnostics.*;
import Std.Convert.*;

operation Main() : Int {
    use qubits = Qubit[3];
    ApplyToEach(H, qubits);
    Message("The qubit register is in a uniform superposition: ");
    DumpMachine();
    mutable results = [];
    for q in qubits {
        Message(" ");
        results += [M(q)];
        DumpMachine();
    }
    ResetAll(qubits);
    Message("Your random number is: ");
    return ResultArrayAsInt(results);
}

  2. Om du vill köra programmet på den inbyggda simulatorn väljer du kör kodlinsen Main ovanför åtgärden eller trycker på Ctrl + F5. Dina utdata visas i felsökningskonsolen.

  3. Granska utdata från DumpMachine och resultatet av mätningen.

Utdata visar hur varje på varandra följande mätning ändrar kvanttillståndet och därmed sannolikheten för att få varje utfall. Vi ska till exempel undersöka varje del av utdata om resultatet är 5:

  • Tillståndsförberedelse: Systemet är i ett lika superpositionstillstånd när du har tillämpat H på varje qubit.

    The qubit register is in a uniform superposition: 

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
 |000⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |001⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |010⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |011⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |100⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |101⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |110⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |111⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000

  • Första mätningen: Resultatet är One för den första mätningen, så nu är de enda möjliga tillstånden som systemet kan hamna i de tillstånd där den vänstra biten är 1. Amplituderna i de tillstånd där den vänstra kvantbiten är 0 har försvunnit och sannolikheten för återstående möjliga tillstånd ökar från 12,5% till 25,0% så att summan av sannolikheterna förblir 100%.

     Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
 |100⟩ |  0.5000+0.0000𝑖 |    25.0000% |   0.0000
 |101⟩ |  0.5000+0.0000𝑖 |    25.0000% |   0.0000
 |110⟩ |  0.5000+0.0000𝑖 |    25.0000% |   0.0000
 |111⟩ |  0.5000+0.0000𝑖 |    25.0000% |   0.0000

  • Andra mätningen: Resultatet är Zero för den andra mätningen, så nu är de enda möjliga tillstånden som systemet kan hamna i de tillstånd där de två vänstra bitarna är 10. Nu har vi bara två möjliga utfall när vi mäter den tredje kvantbiten, med en sannolikhet på 50% för varje utfall.

     Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
 |100⟩ |  0.7071+0.0000𝑖 |    50.0000% |   0.0000
 |101⟩ |  0.7071+0.0000𝑖 |    50.0000% |   0.0000

  • Tredje mätningen: I den tredje mätningen är Oneresultatet . Systemet är helt mätt och är därför inte längre i ett superpositionsläge som förväntat.

     Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
 |101⟩ |  1.0000+0.0000𝑖 |   100.0000% |   0.0000

Your random number is: 

5

Med Q#kan du skapa ett system med kvantbitar, placera kvantbitarna i ett superpositionstillstånd och undersöka hur systemet ändras när du tillämpar kvantåtgärder eller utför mätningar.