Rychlý start: Vytvoření prvního Q# programu

Naučte se psát základní Q# program, který demonstruje propletení, klíčový koncept kvantového computingu.

Když jsou dva nebo více qubitů propletené, sdílejí kvantové informace, což znamená, že cokoli se stane s jedním qubitem, se také stane s druhým. V tomto rychlém úvodu vytvoříte konkrétní dvouqubitový propletený stav zvaný Bellův pár. Pokud v páru Bell změříte jeden qubit ve $\ket{0}$ stavu, víte, že druhý qubit je také ve $\ket{0}$ stavu bez měření. Další informace najdete v tématu Propletení kvantových dat.

V tomto rychlém průvodci:

• Vytvořte soubor Q#.
• Přidělte pár qubitů.
• Propletení qubitů.

Požadavky

• Nejnovější verze editoru Visual Studio Code.
• Rozšíření Azure Quantum Development Kit (QDK). Podrobnosti o instalaci najdete v tématu Nastavení sady Quantum Development Kit.

Vytvoření Q# souboru

1. Otevřete Visual Studio Code.
2. Vyberte Soubor>nový textový soubor.
3. Uložte soubor jako Main.qs. Přípona .qs označuje Q# program.

Napište svůj Q# kód

Ve vašem Main.qs souboru postupujte podle těchto kroků k zamotání a měření páru qubitů.

Import kvantové knihovny

Sada QDK obsahuje standardní knihovnu Q# s předdefinovanými funkcemi a operacemi pro kvantové programy. Pokud je chcete použít, musíte nejprve importovat příslušnou knihovnu.

V programu použijte příkaz import k otevření Std.Diagnostics knihovny. Tím získáte přístup ke všem funkcím a operacím knihovny, včetně DumpMachine, které později použijete k zobrazení propleteného stavu.

import Std.Diagnostics.*;

Definování operace

Po importu příslušných knihoven definujte svou kvantovou operaci a její vstupní a výstupní hodnoty. Pro účely tohoto rychlého průvodce je vaše operace Main. Tady napíšete zbývající Q# kód pro přidělení, manipulaci a měření dvou qubitů.

Main nepřijímá žádné parametry a vrací dvě Result hodnoty, buď Zero nebo One, které představují výsledky měření qubitu:

    operation Main() : (Result, Result) {
        // Your entanglement code goes here.
}

Přidělení dvou qubitů

Operace Main je aktuálně prázdná, takže dalším krokem je přidělení dvou qubitů q1 a q2. V Q#, přidělíte qubity pomocí klíčového slova use.

        // Allocate two qubits, q1 and q2, in the 0 state.
        use (q1, q2) = (Qubit(), Qubit());

Poznámka:

V Q# jsou qubity vždy přiděleny ve stavu $\ket{0}$.

Vložení jednoho qubitu do superpozice

Qubity q1 a q2 jsou ve $\ket{0}$ stavu. Chcete-li připravit qubity na propletení, musíte jeden z nich umístit do sudé superpozice, kde má 50% šanci na měření jako $\ket{0}$ nebo $\ket{1}$.

Qubit vložíte do superpozice použitím hadamardu, Hoperace:

        // Put q1 into an even superposition.
        H(q1);

Výsledný stav q1 je $\frac{{1}{\sqrt{2}}(\ket{{0}+\ket{1}),$ což je i superpozice $\ket{0}$ a $\ket{{1}$.

Propletení qubitů

Teď jste připraveni propletit qubity pomocí operace řízená-NOT, CNOT. CNOT je řídicí operace, která přebírá dva qubity, jeden funguje jako ovládací prvek a druhý jako cíl.

Pro účely tohoto rychlého startu nastavíte q1 jako řídicí qubit a q2 cílový qubit. To znamená, že CNOT překlápí stav q2, když je stav q1$\ket{1}$.

        // Entangle q1 and q2, making q2 depend on q1.
        CNOT(q1, q2);

Výsledný stav obou qubitů je Bellův pár $\frac{{1}{\sqrt{2}}(\ket{00}+\ket{{11})$.

Tip

Pokud chcete zjistit, jak operace Hadamard a CNOT transformují stav qubitů, přečtěte si téma Vytváření propletení s kvantovými operacemi.

Zobrazení propleteného stavu

Než změříte qubity, je důležité ověřit, že je předchozí kód úspěšně propletl. DumpMachine K výstupu Std.Diagnostics aktuálního stavu programu Q# použijte operaci, která je součástí knihovny:

    // Show the entangled state of the qubits.
    DumpMachine();

Měření qubitů

Teď, když jste ověřili, že jsou qubity propletené, můžete k měření použít M operaci. Měřením se kolabují jejich kvantové stavy na q1 nebo q2 s rovnoměrnou pravděpodobností.

V Q# použijte klíčové slovo let k deklaraci nové proměnné. Chcete-li uložit výsledky měření q1 a q2, deklarujte proměnné m1 a m2 v uvedeném pořadí:

        // Measure q1 and q2 and store the results in m1 and m2.
        let (m1, m2) = (M(q1), M(q2));

Resetování qubitů

Před vydáním na konci každého Q# programu musí být qubity ve $\ket{0}$ stavu. Provedete to pomocí Reset operace:

        // Reset q1 and q2 to the 0 state.
        Reset(q1);
        Reset(q2);

Vrácení výsledků měření

Ke konci dokončete operaci Main a sledujte propletený stav, zaznamenejte výsledky měření m1 a m2.

        // Return the measurement results.
        return (m1, m2);

Tip

Pokud chcete získat další informace o Q# funkci nebo operaci, najeďte myší na ni.

Spusťte svůj Q# kód

Gratulujeme! Napsali Q# jste program, který proplete dva qubity a vytvoří Bellův pár.

Konečný Q# program by měl vypadat takto:

import Std.Diagnostics.*;

operation Main() : (Result, Result) {  
    // Allocate two qubits, q1 and q2, in the 0 state.
    use (q1, q2) = (Qubit(), Qubit());
    
    // Put q1 into an even superposition.
    // It now has a 50% chance of being measured as 0 or 1.
    H(q1);
    
    // Entangle q1 and q2, making q2 depend on q1.
    CNOT(q1, q2);
    
    // Show the entangled state of the qubits.
    DumpMachine();
    
    // Measure q1 and q2 and store the results in m1 and m2.
    let (m1, m2) = (M(q1), M(q2));
    
    // Reset q1 and q2 to the 0 state.
    Reset(q1);
    Reset(q2);
    
    // Return the measurement results.
    return (m1, m2);
}

Pokud chcete spustit program a zobrazit výsledek obou qubitů, vyberte Spustit nad Main operací nebo stiskněte Ctrl+F5.

Program můžete spustit několikrát, z nichž každý má jiný výsledek v konzole ladění. To ukazuje pravděpodobnostní povahu kvantových měření a propletení qubitů.

Pokud je výsledkem například Zero, měla by konzole ladění vypadat takto:

DumpMachine:

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
  |00⟩ |  0.7071+0.0000𝑖 |    50.0000% |   0.0000
  |11⟩ |  0.7071+0.0000𝑖 |    50.0000% |   0.0000

Result: "(Zero, Zero)"

Další krok

Další informace o kvantovém propletení pomocí Q#najdete v kurzu : Prozkoumání kvantového propletení pomocí Q#. Tento kurz rozšiřuje koncepty popsané v tomto rychlém úvodu a pomáhá vám napsat pokročilejší program propletení.