Szybki start: tworzenie pierwszego Q# programu

Artykuł
10/29/2024

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 przewodniku Szybki start utworzysz określony stan splątania dwóch kubitów nazywany parą Bell. 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:

Utwórz plik Q#.
Przydziel parę kubitów.
Splątanie kubitów.

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

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

Q# Pisanie kodu

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ę Microsoft.Quantum.Diagnostics . Zapewnia to dostęp do wszystkich jego funkcji i operacji, w tym DumpMachine(), których później używasz do wyświetlania stanu splątanego.

    import Microsoft.Quantum.Diagnostics.*;

Definiowanie operacji

Po zaimportowaniu odpowiednich bibliotek zdefiniuj operację kwantową oraz jej wartości wejściowe i wyjściowe. W tym przewodniku Szybki start 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 i q2q1 . 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());

Uwaga

W Q#systemie kubity są zawsze przydzielane w $\ket{0}$ stanie .

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 nawet 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}}({0}\ket{+\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, jedną działającą jako kontrolkę, a drugą jako docelową.

W tym przewodniku Szybki start ustawisz q1 kubit kontrolny i q2 jako kubit docelowy. Oznacza CNOT to przerzucanie stanu q2 , gdy stan q1 to $\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})$.

Napiwek

Jeśli chcesz dowiedzieć się, jak operacje Hadamard i CNOT przekształcają stan kubitów, zobacz Tworzenie splątania za pomocą operacji kwantowych.

Wyświetlanie stanu splątanego

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

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

Mierzenie kubitów

Po zweryfikowaniu splątania kubitów możesz użyć M operacji do ich zmierzenia. Mierzenie i zwijanie q1 stanów kwantowych do Zero lub One nawet z prawdopodobieństwem.q2

W Q#programie słowo kluczowe służy let 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 wydaniem na końcu każdego Q# programu kubity muszą znajdować się w $\ket{0}$ stanie . 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 m1 pomiaru i m2:

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

Napiwek

Jeśli chcesz dowiedzieć się więcej na temat Q# funkcji lub operacji, umieść kursor na niej.

Zrzut ekranu przedstawiający szczegóły wyświetlane po umieszczeniu wskaźnika myszy na operacji

Q# Uruchamianie kodu

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 Microsoft.Quantum.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

Q# Zrzut ekranu przedstawiający plik w programie Visual Studio Code pokazujący, gdzie znaleźć polecenie

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 za pomocą Q#programu , zobacz Samouczek: eksplorowanie splątania kwantowego za pomocą polecenia Q#. Ten samouczek rozszerza pojęcia omówione w tym przewodniku Szybki start i ułatwia pisanie bardziej zaawansowanego programu splątania.

Udostępnij za pośrednictwem