Ö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 utforska superpositionen i Q# genom att skriva lite kod.

I den här lektionen DumpMachine skapar du kvantsuperposition och undersöker sannolikheter med Q# med hjälp av funktionen . Funktionen DumpMachine dumpar information om kvantsystemets aktuella status vid den punkt där det anropas.

Skapa en ny Q#-fil

  1. Öppna Visual Studio Code.
  2. I Visual Studio Code väljer du Fil > Ny textfil och sparar filen som Main.qs.
  3. Välj Visa –> Kommandopalett och skriv Q#: Ange Azure Quantum QIR-målprofilen. Tryck på Retur.
  4. Välj Q#: Obegränsad.

Kom igång med superposition

Vi börjar med ett enkelt program som genererar en slumpmässig bit med hjälp av en qubit i superposition. Du använder DumpMachine funktionen för att se qubitens tillstånd vid olika tidpunkter i programmet.

  1. Lägg till följande kod i filen Main.qs :

    import Microsoft.Quantum.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;
}

    Här anropar du DumpMachine fyra gånger:

    • Efter att qubit har allokerats.
    • När du har lagt qubiten i superposition.
    • När du har mätt kvantbitens tillstånd.
    • När du har återställt kvantbiten.

    Du delar upp åtgärden MResetZ i två åtgärder: M och Reset. Du gör det eftersom du vill kontrollera tillståndet efter mätningen.

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

  3. Funktionen DumpMachine skapar en tabell med information som beskriver qubitregistrets tillstånd. Mer specifikt ger det sannolikhetsamplituden, sannolikheten och fasen i radianer för varje grundtillstånd.

  4. I slutet av programmet får du ett resultat på Zero eller One. Nu ska vi titta på varje steg.

    1. Initierad qubit: Varje qubit som allokeras med instruktionen use startar i tillståndet $|0\rangle$. Därmed skapar DumpMachine den information som motsvarar ett register för en enskild qubit i tillståndet $|0\rangle$.

      Initialized qubit:

DumpMachine:

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

    2. Qubit efter att ha tillämpat H: När vi har tillämpat Hförbereder vi kvantbiten i superpositionstillståndet $|\psi\rangle=\frac1{\sqrt2} |0\rangle + \frac1{\sqrt2} |1\rangle$.

      Qubit after applying H:

DumpMachine:

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

    3. Qubit efter mätningen: När vi har mätt och lagrat resultatet, som kan vara en Zero eller One. Om det resulterande tillståndet till exempel är Onekomprimeras tillståndet för register till $|1\rangle$ och är inte längre i superposition.

      Qubit after the measurement:

DumpMachine:

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

    4. Qubit efter återställning: Åtgärden Reset återställer kvantbiten till tillståndet $|0\rangle$. Kom ihåg att du för varje Q#-åtgärd behöver alltid behöver låta de qubitar du använder vara kvar i tillståndet $|0\rangle$ så att den kan användas av andra åtgärder.

      Qubit after resetting:

DumpMachine:

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

    Kommentar

    Dina utdata kan skilja sig eftersom slumptalsgeneratorn är probabilistisk. Sannolikheten för utfallen är inte deterministisk.

Utforska andra typer av superpositionstillstånd

Nu när du vet hur du inspekterar tillståndet för ett register kan du se fler åtgärder som ändrar tillståndet för dina kvantbitar och placerar dem i en superposition.

Den aktuella slumptalsgeneratorn ger antingen Zero eller One med en sannolikhet på 50 %. Nu ska vi titta på ett andra exempel som genererar slumpmässiga tal med olika sannolikheter.

Förskjuten slumpmässig bit-generator

Anta att du vill skapa en slumpmässig bitgenerator som är skev, det vill säga 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$$

Här är $\alpha=\sqrt{P}$ och $\beta=\sqrt{1-P}$ amplituderna för bastillstånden $|0\rangle$ respektive $|1\rangle$.

Det här tillståndet kan erhållas genom att sekventiellt tillämpa operatorn $R_y(2\arccos\sqrt{P})$ på en qubit i tillståndet $|0\rangle.$ Du kan uppnå det här resultatet i Q# med hjälp av åtgärden Ry i standardbiblioteket.

Dricks

Mer information om matematiken bakom enkla kvantbitsåtgärder finns i självstudien Single-Qubit Gates i Quantum Katas.

  1. Ändra Main.qs som i följande exempel och spara sedan filen. Det här exemplet väljer $\alpha$ för att vara ungefär $\frac13$.

    import Microsoft.Quantum.Diagnostics.*;
import Microsoft.Quantum.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.");
    Message("");
    DumpMachine(); // Dump the state of the qubit 
    Message("");
    Message("Your skewed random bit is:");
    let skewedrandomBit = M(q);
    Reset(q);
    return skewedrandomBit;
}

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

  3. Du kan se hur DumpMachine visar det förväntade tillståndet efter att det har tillämpat åtgärderna och visar de associerade sannolikheterna. Observera att sannolikheten för att få Zero är cirka 33,33 % och sannolikheten för att få One är cirka 66,67 %. Därför är den slumpmässiga bitgeneratorn skev.

    The qubit is in the desired state.

DumpMachine:

 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:
Result: "One"

    Kommentar

    Dina utdata kan skilja sig eftersom slumptalsgeneratorn är probabilistisk. Sannolikheten för utfallen är inte deterministisk.

Superposition för flera qubitsar

Nu ska vi utforska superpositioner för ett register som omfattar många qubitar. Om ditt register till exempel består av tre qubitar har du åtta bastillstånd:

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

Du kan därför uttrycka ett godtyckligt tillstånd för tre qubitar som:

$$|\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$$

Här är $\alpha_i$ komplexa tal som uppfyller $\sum|\alpha_i|^2=1$.

Du kan till exempel placera kvantbitar i en enhetlig superposition genom att tillämpa på H varje qubit. Du kan använda den här enhetliga superpositionen för att skapa en annan version av den kvantslumptalsgenerator som genererar tre-bittal genom att mäta tre qubitar i superposition i stället för att mäta en qubit tre gånger.

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

  1. Ändra Main.qs som i följande exempel och spara sedan filen.

    import Microsoft.Quantum.Diagnostics.*;
import Microsoft.Quantum.Math.*;
import Microsoft.Quantum.Convert.*;
import Microsoft.Quantum.Arrays.*;

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

    Här ser du tre begrepp:

    • Variabeln qubits representerar nu en Qubit-matris som har längden tre.
    • Åtgärderna ApplyToEach och ForEach är användbara för att mäta och agera på flera kvantbitar, och de använder mindre kod. Q#-bibliotek erbjuder många typer av åtgärder och funktioner som gör det mer effektivt att skriva kvantprogram.
    • Funktionerna BoolArrayAsInt och ResultArrayAsBoolArray från Microsoft.Quantum.Convert biblioteket omvandlar den binära Result matris som returneras av ForEach(M, qubits) till ett heltal.

  2. Om du vill köra programmet klickar du på Kör ovanför åtgärden Main eller trycker på Ctrl+F5. Dina utdata visas i felsökningskonsolen.

  3. Med hjälp av DumpMachine ser du hur mätningen av tre qubitar kollapsar registrets tillstånd till ett av de åtta möjliga bastillstånden. Om du till exempel får resultatet 3innebär det att registrets tillstånd har minimerats till $|110\rangle$.

    The qubit register in a uniform superposition:

DumpMachine:

 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.

DumpMachine:

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

Result: "3"

    Kommentar

    Dina utdata kan skilja sig eftersom slumptalsgeneratorn är probabilistisk. Sannolikheten för utfallen är inte deterministisk.

  4. Åtgärden ForEach(M, qubit) mäter varje qubit i turordning och kollapsar gradvis tillståndet. Du kan också dumpa mellanliggande tillstånd efter varje mätning. Om du vill göra det ändrar du Main.qs som i följande exempel och sparar sedan filen.

    import Microsoft.Quantum.Diagnostics.*;
import Microsoft.Quantum.Measurement.*;
import Microsoft.Quantum.Math.*;
import Microsoft.Quantum.Convert.*;

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

  5. Här använder du en for-slinga för att agera på varje qubit sekventiellt. Q# har klassiska flödeskontrollfunktioner, till exempel for loopar och if instruktioner, som du kan använda för att styra flödet i ditt program.

  6. Om du vill köra programmet klickar du på Kör från listan med kommandon ovanför Main åtgärden eller trycker på Ctrl+F5.

  7. Du kan se hur varje efterföljande mätning ändrar kvanttillståndet och därmed sannolikheten att få varje resultat. Om resultatet till exempel är nummer fem får du följande utdata. Vi tittar kort på varje steg:

    1. Tillståndsförberedelse: När vi har tillämpat H på varje kvantbit i registret får vi en enhetlig superposition.

      The qubit register in a uniform superposition: 

DumpMachine:

 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

    2. Första mätningen: I den första mätningen blev Oneresultatet . Därför är alla amplituder för de tillstånd vars qubit längst till höger är Zero inte längre tillgängliga. Amplituderna är $|0\rangle=|000\rangle, |2\rangle=|010\rangle, |4\rangle=|100\rangle$ och $|6\rangle= |110\rangle$. Resten av amplituderna ökar för att uppfylla normaliseringsvillkoret.

      DumpMachine:

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
 |001⟩ |  0.5000+0.0000𝑖 |    25.0000% |   0.0000
 |011⟩ |  0.5000+0.0000𝑖 |    25.0000% |   0.0000
 |101⟩ |  0.5000+0.0000𝑖 |    25.0000% |   0.0000
 |111⟩ |  0.5000+0.0000𝑖 |    25.0000% |   0.0000

    3. Andra mätningen: I den andra mätningen blev Zeroresultatet . Därför försvinner alla amplituder för de tillstånd vars qubit näst längst till höger (i mitten) är One. Amplituderna är $|3\rangle=|011\rangle$ and $|7\rangle=|111\rangle$. Resten av amplituderna ökar för att uppfylla normaliseringsvillkoret.

      DumpMachine:

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

    4. Tredje mätningen: I den tredje mätningen blev Oneresultatet . Därför rensas alla amplituder i de tillstånd vars vänstra qubit är Zero klar. Det enda kompatibla tillståndet är $|5\rangle=|101\rangle$. Det här tillståndet får en amplitudsannolikhet på $1$.

      DumpMachine:

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


Your random number is: 
Result: "5"

    Kommentar

    Dina utdata kan skilja sig eftersom slumptalsgeneratorn är probabilistisk. Sannolikheten för utfallen är inte deterministisk.