Szybki start: tworzenie pierwszego Q# programu

Dowiedz się, jak napisać podstawowy Q# program, który demonstruje splątanie— kluczową koncepcję obliczeń kwantowych.

Gdy co najmniej dwa kubity są splątane, współdzielą informacje kwantowe, co oznacza, że cokolwiek się dzieje z jednym kubitem, również dzieje się z drugim. W tym szybkim przewodniku utworzysz określony stan splątany dwóch kubitów zwany parą Bella. W parze Bell, jeśli mierzysz jeden kubit w $\ket{0}$ stanie, wiesz, że drugi kubit jest również w $\ket{0}$ stanie bez mierzenia go. Aby uzyskać więcej informacji, zobacz Splątanie kwantowe.

W ramach tego przewodnika Szybki start wykonasz następujące czynności:

Wymagania wstępne

• Najnowsza wersja programu Visual Studio Code.
• Rozszerzenie zestawu Azure Quantum Development Kit (QDK). Aby uzyskać szczegółowe informacje na temat instalacji, zobacz Konfigurowanie zestawu Quantum Development Kit.

Tworzenie Q# pliku

1. Otwórz Visual Studio Code.
2. Wybierz pozycję Plik>Nowy plik tekstowy.
3. Zapisz plik jako Main.qs. Rozszerzenie .qs oznacza Q# program.

Napisz swój Q# kod

W pliku Main.qs wykonaj następujące kroki, aby splątać i zmierzyć parę kubitów.

Importowanie biblioteki kwantowej

Zestaw QDK zawiera standardową bibliotekę Q# ze wstępnie zdefiniowanymi funkcjami i operacjami dla programów kwantowych. Aby ich używać, należy najpierw zaimportować odpowiednią bibliotekę.

W programie użyj import instrukcji, aby otworzyć bibliotekę Std.Diagnostics. Zapewnia to dostęp do wszystkich funkcji i operacji biblioteki, w tym DumpMachine, których później używasz do wyświetlania stanu splątanego.

import Std.Diagnostics.*;

Definiowanie operacji

Po zaimportowaniu odpowiednich bibliotek zdefiniuj operację kwantową oraz jej wartości wejściowe i wyjściowe. W tym przewodniku szybkiego startu operacja to Main. W tym miejscu napiszesz pozostały Q# kod do przydzielenia, manipulowania i mierzenia dwóch kubitów.

Main nie przyjmuje żadnych parametrów i zwraca dwie Result wartości albo Zero lub One, które reprezentują wyniki pomiarów kubitu:

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

Przydzielanie dwóch kubitów

Operacja Main jest obecnie pusta, więc następnym krokiem jest przydzielenie dwóch kubitów, q1 i q2. W Q#systemie przydzielasz kubity przy użyciu słowa kluczowego use :

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

Umieść jeden kubit w superpozycję

Kubity q1 i q2 znajdują się w $\ket{0}$ stanie . Aby przygotować kubity do splątania, należy umieścić jeden z nich w równomiernej superpozycji, gdzie ma 50% szans na pomiar jako $\ket{0}$ lub $\ket{1}$.

Kubit można umieścić w superpozycji, stosując operację Hadamard, H, :

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

Wynikowy stan q1 to $\frac{{1}{\sqrt{2}}(\ket{{0}+\ket{1})$, czyli parzysta superpozycja $\ket{0}$ i $\ket{{1}$.

Splątanie kubitów

Teraz możesz przystąpić do splątania kubitów przy użyciu kontrolowanej operacji NOT, CNOT, . CNOT jest operacją kontrolną, która przyjmuje dwa kubity, z których jeden działa jako sterujący, a drugi jako docelowy.

W tym przewodniku szybki start ustawiasz q1 jako kubit kontrolny i q2 jako kubit docelowy. To oznacza, że CNOT zmienia stan q2, gdy stan q1 wynosi $\ket{1}$.

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

Wynikowy stan obu kubitów to para $\frac{{1}{\sqrt{2}}Bell (\ket{00}+\ket{{11})$.

Wyświetlanie stanu splątanego

Przed zmierzaniem kubitów należy sprawdzić, czy poprzedni kod pomyślnie je splątuje. DumpMachine Użyj operacji , która jest częścią Std.Diagnostics biblioteki, aby wyświetlić bieżący stan Q# programu:

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

Mierzenie kubitów

Po zweryfikowaniu, że kubity są splątane, możesz użyć operacji M do ich zmierzenia. Pomiar q1 i q2 powoduje kolaps ich stanów kwantowych do Zero lub One z równym prawdopodobieństwem.

W Q# słowo kluczowe let służy do deklarowania nowej zmiennej. Aby przechowywać wyniki pomiarów q1 i q2, zadeklaruj odpowiednio zmienne m1 i m2:

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

Resetowanie kubitów

Przed uwolnieniem na zakończenie każdego Q# programu, kubity muszą znajdować się w stanie $\ket{0}$. W tym celu należy wykonać operację Reset :

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

Zwracanie wyników pomiaru

Na koniec, aby ukończyć operację Main i obserwować splątany stan, zwróć wyniki pomiarów m1 i m2.

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

Uruchom swój Q# kod

Gratulacje! Napisałeś Q# program, który spląta dwa kubity i tworzy parę Bell.

Q# Ostateczny program powinien wyglądać następująco:

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

Aby uruchomić program i wyświetlić wynik obu kubitów, wybierz pozycję Uruchom powyżej Main operacji lub naciśnij Ctrl+F5

Program można uruchomić kilka razy, z których każdy ma inny wynik w konsoli debugowania. Pokazuje to probabilistyczne charakter pomiarów kwantowych i splątanie kubitów.

Jeśli na przykład wynikiem jest Zero, konsola debugowania powinna wyglądać następująco:

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)"

Następny krok

Aby dowiedzieć się więcej na temat splątania kwantowego z Q#, zobacz także Samouczek: Eksplorowanie splątania kwantowego z Q#. Ten samouczek rozszerza pojęcia omówione w tym przewodniku Szybki start i ułatwia pisanie bardziej zaawansowanego programu splątania.