Prozkoumání superpozice pomocí Q#

  • 12 min

V předchozích lekcích jste se dozvěděli o superpozici a zápisu Dirac. To je teď dost teorie! Pojďme se podívat na superpozici v Q# napsáním kódu.

V této lekci vytvoříte kvantovou superpozici a pomocí funkce se seznámíte s pravděpodobnostmi pomocí jazyka DumpMachine Q#. Funkce DumpMachine vysadí informace o aktuálním stavu kvantového systému v okamžiku, kdy je volána.

Vytvoření nového souboru Q#

  1. Otevřete Visual Studio Code.
  2. V editoru Visual Studio Code vyberte Soubor > nový textový soubor a uložte ho jako Main.qs.
  3. Vyberte Zobrazit –> Paleta příkazů a zadejte Q#: Nastavte cílový profil Azure Quantum QIR. Stiskněte klávesu Enter.
  4. Vyberte Q#: Neomezené.

Začínáme se superpozicí

Začněme jednoduchým programem, který vygeneruje náhodný bit pomocí qubitu v superpozici. DumpMachine Pomocí funkce uvidíte stav qubitu v různých bodech programu.

  1. Do souboru Main.qs přidejte následující kód:

    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;
}

    Tady DumpMachine zavoláte čtyřikrát:

    • Po přidělení qubitu.
    • Po umístění qubitu do superpozice.
    • Po měření stavu qubitu.
    • Po resetování qubitu.

    Operaci MResetZ rozdělíte do dvou operací: M a Reset. Uděláte to, protože chcete prozkoumat stav po měření.

  2. Pokud chcete program spustit na integrovaném simulátoru, klikněte nad Main operací nebo stiskněte Kombinaci kláves Ctrl+F5. Výstup se zobrazí v konzole ladění.

  3. Funkce DumpMachine vytvoří tabulku s informacemi, které popisují stav registru qubitu. Konkrétně poskytuje pro každý bázový stav amplitudu pravděpodobnosti, pravděpodobnost a fázi v radiánech.

  4. Na konci programu získáte výsledek Zero nebo One. Pojďme se podívat na jednotlivé kroky.

    1. Inicializovaný qubit: Každý qubit přidělený příkazem use začíná ve stavu $|0\rangle$. Funkce DumpMachine tedy vytvoří informace, které odpovídají registru s jedním qubitem ve stavu $|0\rangle$.

      Initialized qubit:

DumpMachine:

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

    2. Qubit po použití H: Po použití Hpřipravíme qubit ve stavu superpozice $|\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 po měření: Po měření a uložení výsledku, který může být nebo Zero One. Pokud je Onenapříklad výsledný stav , stav registrů se sbalí na $|1\rangle$ a už není v superpozici.

      Qubit after the measurement:

DumpMachine:

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

    4. Qubit po resetování: Operace Reset resetuje qubit do stavu $|0\rangle$. Nezapomínejte, že u všech operací v jazyce Q# je nutné vámi používané qubity nechat ve stavu $|0\rangle$, aby je mohly používat jiné operace.

      Qubit after resetting:

DumpMachine:

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

    Poznámka:

    Výstupy se můžou lišit, protože generátor náhodných čísel je pravděpodobnostní. Pravděpodobnosti výsledků nejsou deterministické.

Prozkoumání dalších typů stavů superpozice

Teď, když víte, jak zkontrolovat stav registru, uvidíte další operace, které upravují stav qubitů a umístí je do superpozice.

Aktuální generátor náhodných čísel vyprodukuje s 50% pravděpodobností Zero nebo One. Pojďme se podívat na druhý příklad, který generuje náhodná čísla s jinou pravděpodobností.

Asymetrický generátor náhodných bitů

Předpokládejme, že chcete vytvořit generátor náhodných bitů, který je zkosený, to znamená, že pravděpodobnost získání Zero se liší od pravděpodobnosti získání One.

Chcete například výsledek Zero s pravděpodobností $P$ a výsledek One s pravděpodobností $1-P$. Tady je platný stav qubitu, který vytváří takový generátor náhodných bitů:

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

Tady jsou amplitudy základního stavu $|0\rangle$ a $|1\rangle$, $\beta=\sqrt{1-P}$.

Tento stav lze získat postupným použitím operátoru $R_y(2\arccos\sqrt{P})$ na qubit ve stavu $|0\rangle.$ Tento výsledek dosáhnete v Q# pomocí operace Ry ve standardní knihovně.

Tip

Další informace o matematických operacích s jedním qubitem najdete v kurzu Jedno qubitové brány v kvantových katách.

  1. Upravte Main.qs podobně jako v následujícím příkladu a pak soubor uložte. Tento příklad zvolí $\alpha$ tak, aby byl přibližně $\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. Pokud chcete program spustit na integrovaném simulátoru, klikněte nad Main operací nebo stiskněte Kombinaci kláves Ctrl+F5. Výstup se zobrazí v konzole ladění.

  3. Můžete si všimnout, jak DumpMachine zobrazuje po použití operací očekávaný stav a také související pravděpodobnosti. Všimněte si, že pravděpodobnost získání Zero je přibližně 33,33 % a pravděpodobnost získání One je přibližně 66,67 %. Proto se generátor náhodných bitů zkosí.

    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"

    Poznámka:

    Výstup se může lišit, protože generátor náhodných čísel je pravděpodobnostní. Pravděpodobnosti výsledků nejsou deterministické.

Superpozice více qubitů

Teď se pojďme podívat na superpozice registru, který obsahuje mnoho qubitů. Pokud máte například registr se třemi qubity, potom máte osm různých bázových stavů:

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

Náhodný tříqubitový stav tedy můžete vyjádřit takto:

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

$\alpha_i$ jsou komplexní čísla, která vyhovují $\sum|\alpha_i|^2=1$.

Qubity můžete například umístit do jednotné superpozice použitím H u každého qubitu. Tuto jednotnou superpozici můžete použít k vytvoření jiné verze kvantového generátoru náhodných čísel, který generuje tříbitová čísla měřením tří qubitů v superpozici, nikoli měřením jednoho qubitu třikrát.

Základ Počet
$\ket{000}$ 0
$\ket{001}$ 0
$\ket{010}$ 2
$\ket{011}$ 3
$\ket{100}$ 4
$\ket{101}$ 5
$\ket{110}$ 6
$\ket{111}$ 7

  1. Upravte Main.qs podobně jako v následujícím příkladu a pak soubor uložte.

    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));
}

    Tady vidíte tři koncepty:

    • Proměnná qubits teď představuje pole Qubit o délce 3.
    • Operace ApplyToEach a ForEach jsou užitečné k měření a práci s více qubity a používají méně kódu. Knihovny Q# nabízí mnoho druhů operací a funkcí, které psaní kvantových programů zefektivňují.
    • Funkce BoolArrayAsInt z ResultArrayAsBoolArray Microsoft.Quantum.Convert knihovny transformují binární Result pole, které je vráceno ForEach(M, qubits) na celé číslo.

  2. Pokud chcete program spustit, klikněte nad Main operací nebo stiskněte Kombinaci kláves Ctrl+F5. Výstup se zobrazí v konzole ladění.

  3. Když použijeme funkci DumpMachine, vidíte, jak měření tří qubitů sbalí stav registru do jednoho z osmi možných bázových stavů. Pokud se například zobrazí výsledek 3, znamená to, že stav registru byl sbalený na $|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"

    Poznámka:

    Výstup se může lišit, protože generátor náhodných čísel je pravděpodobnostní. Pravděpodobnosti výsledků nejsou deterministické.

  4. Operace ForEach(M, qubit) postupně měří jednotlivé qubity a sbaluje stav. Po každém měření můžete také vyhodit zprostředkující stavy. Uděláte to tak, že upravíte Main.qs jako v následujícím příkladu a pak soubor uložíte.

    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. Použijete zde smyčku for, která bude následně působit na každý qubit. Q# má klasické možnosti řízení toku, jako for jsou smyčky a if příkazy, které můžete použít k řízení toku programu.

  6. Program spustíte tak, že v seznamu příkazů nad operací kliknete na Spustit nebo stisknete Ctrl+F5.Main

  7. Můžete si všimnout, jak každé další po sobě jdoucí měření mění kvantový stav, a tím i pravděpodobnosti získání jednotlivých výstupů. Pokud je například výsledek číslo pět, zobrazí se následující výstup. Pojďme se krátce podívat na jednotlivé kroky:

    1. Příprava stavu: Po použití H na každý qubit registru získáme jednotnou superpozici.

      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. První měření: V prvním měření byl Onevýsledek . Proto už nejsou přítomné všechny amplitudy stavů, jejichž qubit umístěný úplně vpravo je Zero. Amplitudy jsou $|0\rangle=|000\rangle, |2\rangle=|010\rangle, |4\rangle=|100\rangle$ a $|6\rangle= |110\rangle$. Zbytek amplitud se zvětší, aby splňovaly normalizační podmínku.

      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. Druhé měření: Ve druhém měření byl Zerovýsledek . Proto zmizí všechny amplitudy stavů, jejichž qubit umístěný jako druhý zprava (uprostřed) je One. Amplitudy jsou $|3\rangle=|011\rangle$ a $|7\rangle=|111\rangle$. Zbytek amplitud se zvětší, aby splňovaly normalizační podmínku.

      DumpMachine:

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

    4. Třetí měření: Ve třetím měření byl Onevýsledek . Proto jsou všechny amplitudy stavů, jejichž qubit úplně vlevo je Zero vymazaný. Jediný kompatibilní stav je $|5\rangle=|101\rangle$. Tento stav má pravděpodobnost amplitudy $1$.

      DumpMachine:

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


Your random number is: 
Result: "5"

    Poznámka:

    Výstup se může lišit, protože generátor náhodných čísel je pravděpodobnostní. Pravděpodobnosti výsledků nejsou deterministické.