Wprowadzenie do języka programowania kwantowego Q#

Q# to ogólny język programowania typu open source do tworzenia i uruchamiania algorytmów kwantowych. Q# jest zawarty w zestawie Quantum Development Kit (QDK). Aby uzyskać więcej informacji, zobacz Konfigurowanie zestawu Quantum Development Kit.

Jako język Q# programowania kwantowego spełnia następujące wymagania dotyczące języka, kompilatora i środowiska uruchomieniowego:

• Niezależny od sprzętu: kubity w algorytmach kwantowych nie są powiązane z konkretnym sprzętem kwantowym ani układem. Q# Kompilator i środowisko uruchomieniowe obsługują mapowanie z kubitów programu do kubitów fizycznych.
• Integruje obliczenia kwantowe i klasyczne: możliwość wykonywania obliczeń klasycznych i kwantowych jest niezbędna w uniwersalnym komputerze kwantowym.
• Szanuje prawa fizyki:Q# i algorytmy kwantowe są zgodne z zasadami fizyki kwantowej. Na przykład nie można bezpośrednio skopiować ani uzyskać dostępu do stanu kubitu w elemecie Q#.

Q# Struktura programu

Przed rozpoczęciem pisania programów kwantowych ważne jest zrozumienie ich struktury i składników. Rozważmy następujący Q# program, który tworzy stan superpozycji:

namespace Superposition {
    @EntryPoint()
    operation MeasureOneQubit() : Result {
        // Allocate a qubit. By default, it's in the 0 state.  
        use q = Qubit();  
        // Apply the Hadamard operation, H, to the state.
        // It now has a 50% chance of being measured as 0 or 1.
        H(q);      
        // Measure the qubit in the Z-basis.
        let result = M(q);
        // Reset the qubit before releasing it.
        Reset(q);
        // Return the result of the measurement.
        return result;
    }
}

Na podstawie komentarzy (//), Superposition program najpierw przydziela kubit, stosuje operację, aby umieścić kubit w superpozycji, mierzy stan kubitu, resetuje kubit, a na koniec zwraca wynik. Podzielmy ten program na jego składniki.

Przestrzenie nazw użytkowników

Q#programy mogą opcjonalnie rozpoczynać się od przestrzeni nazw zdefiniowanej przez użytkownika, takiej jak:

namespace Superposition {
    // Your code goes here.
}

Przestrzenie nazw mogą ułatwić organizowanie powiązanych funkcji. Każdy Q# program może mieć tylko jeden namespaceprogram . Jeśli nie określono przestrzeni nazw, Q# kompilator używa nazwy pliku jako przestrzeni nazw. Na przykład Superposition program może być napisany jako:

@EntryPoint()
operation MeasureOneQubit() : Result {
    // Allocate a qubit. By default, it's in the 0 state.  
    use q = Qubit();  
    // Apply the Hadamard operation, H, to the state.
    // It now has a 50% chance of being measured as 0 or 1.
    H(q);      
    // Measure the qubit in the Z-basis.
    let result = M(q);
    // Reset the qubit before releasing it.
    Reset(q);
    // Return the result of the measurement.
    return result;
}

Biblioteka Q# standardowa zawiera wstępnie zdefiniowane przestrzenie nazw, które zawierają funkcje i operacje, których można używać w programach kwantowych. Aby uzyskać więcej informacji, zobacz Wbudowane przestrzenie nazw.

Punkty wejścia

Domyślnie Q# kompilator uruchamia wykonywanie programu z Main() operacji, jeśli jest dostępna, która może znajdować się w dowolnym miejscu w programie. Opcjonalnie możesz użyć atrybutu @EntryPoint() , aby określić dowolną operację w programie jako punkt wykonywania.

Superposition W programie bardziej opisowa MeasureOneQubit() operacja to punkt wejścia programu.

@EntryPoint()
operation MeasureOneQubit() : Result {
    ...

Jednak program można również zapisać bez atrybutu @EntryPoint() , zmieniając MeasureOneQubit() nazwę operacji na Main():

// The Q# compiler automatically detects the Main() operation as the entry point. 

operation Main() : Result {
    // Allocate a qubit. By default, it's in the 0 state.  
    use q = Qubit();  
    // Apply the Hadamard operation, H, to the state.
    // It now has a 50% chance of being measured as 0 or 1.
    H(q);      
    // Measure the qubit in the Z-basis.
    let result = M(q);
    // Reset the qubit before releasing it.
    Reset(q);
    // Return the result of the measurement.
    return result;
}

Typy

Q# Udostępnia wbudowane typy , które są wspólne dla większości języków, w tym Int, Double, Booli , i Stringtypów specyficznych dla obliczeń kwantowych. Na przykład Result typ reprezentuje wynik pomiaru kubitu i może mieć jedną z dwóch wartości: Zero lub One.

Superposition W programie MeasureOneQubit() operacja zwraca Result typ, który odpowiada zwracaniu typu M operacji. Wynik pomiaru jest przechowywany w nowej zmiennej zdefiniowanej przy użyciu instrukcji let :

// The operation definition returns a Result type.
operation MeasureOneQubit() : Result {
    ...
    // Measure the qubit in the Z-basis, returning a Result type.
    let result = M(q);
    ...

Q# Udostępnia również typy definiujące zakresy, tablice i krotki. Można nawet zdefiniować własne typy niestandardowe.

Przydzielanie kubitów

W Q#systemie przydzielasz kubity przy użyciu słowa kluczowego use . Kubity są zawsze przydzielane w $\ket{0}$ stanie.

Program Superposition definiuje jeden kubit:

// Allocate a qubit.
use q = Qubit();

Możesz również przydzielić wiele kubitów i uzyskać do nich dostęp za pośrednictwem jego indeksu:

use qubits = Qubit[2]; // Allocate two qubits.
H(qubits[0]); // Apply H to the first qubit.
X(qubits[1]); // Apply X to the second qubit.

Aby uzyskać więcej informacji, zobacz Use statement (Używanie instrukcji).

Operacje kwantowe

Po przydzieleniu kubitu można przekazać go do operacji i funkcji, nazywanych również wywołaniami. Operacje to podstawowe bloki Q# konstrukcyjne programu. Q# Operacja jest podroutyną kwantową lub procedurą wywoływaną, która zawiera operacje kwantowe, które zmieniają stan rejestru kubitów.

Aby zdefiniować operację Q# , należy określić nazwę operacji, jej dane wejściowe i dane wyjściowe. Superposition W programie MeasureOneQubit() operacja jest zasadniczo całym programem. Nie przyjmuje żadnych parametrów i zwraca Result typ:

operation MeasureOneQubit() : Result {
    ...
}

Oto podstawowy przykład, który nie przyjmuje żadnych parametrów i nie oczekuje wartości zwracanej. Wartość jest równoważna UnitNULL w innych językach:

operation SayHelloQ() : Unit {
    Message("Hello quantum world!");
}

Standardowa Q# biblioteka udostępnia również operacje, których można używać w programach kwantowych, takich jak operacja Hadamard, Hw Superposition programie. Biorąc pod uwagę kubit w bazie Z, H umieszcza kubit w nawet superpozycji, gdzie ma 50% szans na pomiar jako Zero lub One.

Mierzenie kubitów

Chociaż istnieje wiele typów pomiarów kwantowych, Q# koncentruje się na przewidywanych pomiarach na pojedynczych kubitach, nazywanych również pomiarami Pauli.

W Q#metodzie Measure operacja mierzy co najmniej jeden kubit w określonej zasadzie Pauli, który może być PauliX, PauliYlub PauliZ. Measure Result Zwraca typ Zero lub One.

Aby zaimplementować pomiar w podstawie $obliczeniowej \lbrace,\ket{0}\rbrace\ket{1}$, można również użyć M operacji, która mierzy kubit w pauli Z-basis. To sprawia, że M jest to równoważne .Measure([PauliZ], [qubit])

Program Superposition używa M operacji:

// Measure the qubit in the Z-basis.
let result = M(q);

Resetowanie kubitów

W Q#systemie kubity muszą znajdować się w stanie po ich wydaniu $\ket{0}$ . Reset Użyj operacji , aby zresetować każdy kubit do $\ket{0}$ stanu przed zwolnieniem go na końcu programu. Niepowodzenie resetowania kubitu powoduje błąd środowiska uruchomieniowego.

// Reset a qubit.
Reset(q);

Wbudowane przestrzenie nazw

Q# Standardowa biblioteka zawiera wbudowane przestrzenie nazw, które zawierają funkcje i operacje, których można używać w programach kwantowych. Na przykład Microsoft.Quantum.Intrinsic przestrzeń nazw zawiera często używane operacje i funkcje, takie jak M mierzenie wyników i Message wyświetlanie komunikatów użytkowników w dowolnym miejscu w programie.

Aby wywołać funkcję lub operację, można określić pełną przestrzeń nazw lub użyć import instrukcji , która udostępnia wszystkie funkcje i operacje dla tej przestrzeni nazw i udostępnia kod. Następujące przykłady wywołają tę samą operację:

Microsoft.Quantum.Intrinsic.Message("Hello quantum world!");

// imports all functions and operations from the Microsoft.Quantum.Intrinsic namespace.
import Microsoft.Quantum.Intrinsic.*;
Message("Hello quantum world!");

// imports just the `Message` function from the Microsoft.Quantum.Intrinsic namespace.
import Microsoft.Quantum.Intrinsic.Message;
Message("Hello quantum world!");

// namespaces in the standard library may be imported using `Std` instead of `Microsoft.Quantum`. 
import Std.Intrinsic.*;
Message("Hello quantum world!");

Program Superposition nie ma żadnych import instrukcji ani wywołań z pełnymi przestrzeniami nazw. Dzieje się tak dlatego, że Q# środowisko programistyczne automatycznie ładuje dwie przestrzenie nazw: Microsoft.Quantum.Core i Microsoft.Quantum.Intrinsic, które zawierają często używane funkcje i operacje.

Przestrzeń nazw można wykorzystać Microsoft.Quantum.Measurement przy użyciu MResetZ operacji optymalizacji Superposition programu. MResetZ łączy operacje pomiaru i resetowania w jeden krok, jak w poniższym przykładzie:

// Import the namespace for the MResetZ operation.
import Microsoft.Quantum.Measurement.*;

@EntryPoint()
operation MeasureOneQubit() : Result {
    // Allocate a qubit. By default, it's in the 0 state.      
    use q = Qubit();  
    // Apply the Hadamard operation, H, to the state.
    // It now has a 50% chance of being measured as 0 or 1. 
    H(q);   
    // Measure and reset the qubit, and then return the result value.
    return MResetZ(q);
}

Opracowywanie programów kwantowych za pomocą Q# usługi Azure Quantum

Q# i Azure Quantum to zaawansowana kombinacja do tworzenia i uruchamiania programów kwantowych. Za pomocą Q# usługi Azure Quantum można pisać programy kwantowe, symulować ich zachowanie, szacować wymagania dotyczące zasobów i uruchamiać je na rzeczywistym sprzęcie kwantowym. Ta integracja umożliwia poznanie potencjału obliczeń kwantowych i opracowanie innowacyjnych rozwiązań złożonych problemów. Bez względu na to, czy jesteś początkującym, czy doświadczonym deweloperem kwantowym, Q# a usługa Azure Quantum udostępnia narzędzia i zasoby potrzebne do odblokowania możliwości obliczeń kwantowych.

Na poniższym diagramie przedstawiono etapy, w których program kwantowy przechodzi podczas opracowywania za pomocą Q# usługi Azure Quantum. Program rozpoczyna się od środowiska deweloperskiego i kończy się przesłaniem zadania do rzeczywistego sprzętu kwantowego.

Przeanalizujmy kroki na diagramie.

Wybierz środowisko projektowe

Uruchamianie programów kwantowych w preferowanym środowisku programistycznym. Możesz użyć edytora kodu online w witrynie internetowej usługi Azure Quantum, hostowanych notesów Jupyter Notebook w obszarze roboczym usługi Azure Quantum w witrynie Azure Portal lub lokalnego środowiska programistycznego z programem Visual Studio Code. Aby uzyskać więcej informacji, zobacz Różne sposoby uruchamiania Q# programów.

Pisanie programu kwantowego

Programy kwantowe można pisać przy Q# użyciu zestawu Quantum Development Kit (QDK). Aby rozpocząć, zobacz Szybki start: tworzenie pierwszego Q# programu.

Oprócz Q#zestawu QDK oferuje obsługę innych języków przetwarzania kwantowego, takich jak Qiskit i Cirq.

Integracja z językiem Python

Możesz używać Q# go samodzielnie lub razem z językiem Python w różnych środowiskach IDE. Na przykład możesz użyć Q# projektu z programem hosta języka Python do wywoływania Q# operacji. Możesz również zintegrować z językiem Q# Python w notesach Jupyter Notebook. Aby uzyskać więcej informacji, zobacz Różne sposoby uruchamiania Q# programów.

Polecenie %%qsharp

Domyślnie Q# programy w notesach Jupyter Notebook używają ipykernel pakietu języka Python. Aby dodać Q# kod do komórki notesu, użyj %%qsharp polecenia , które jest włączone w qsharp pakiecie języka Python, a następnie kodu Q# .

W przypadku korzystania z programu %%qsharpnależy pamiętać o następujących kwestiach:

• Aby włączyć import qsharpelement , należy najpierw uruchomić polecenie %%qsharp .
• %%qsharp zakresy do komórki notesu, w której jest wyświetlana, i zmienia typ komórki z języka Python na Q#.
• Nie można umieścić instrukcji języka Python przed lub po %%qsharp.
• Q# %%qsharp poniższy kod musi być zgodny ze składniąQ#. Na przykład użyj polecenia // zamiast # do oznaczania komentarzy i ; wierszy kodu końcowego.

Szacowanie zasobów

Przed uruchomieniem rzeczywistego sprzętu kwantowego należy ustalić, czy program może działać na istniejącym sprzęcie i ile zasobów będzie zużywać.

Narzędzie do szacowania zasobów usługi Azure Quantum pozwala ocenić decyzje dotyczące architektury, porównać technologie kubitu i określić zasoby potrzebne do wykonania danego algorytmu kwantowego. Możesz wybrać spośród wstępnie zdefiniowanych protokołów odpornych na błędy i określić założenia bazowego modelu fizycznego kubitu.

Aby uzyskać więcej informacji, zobacz Uruchamianie pierwszego oszacowania zasobów.

Uruchamianie programu w symulacji

Podczas kompilowania i uruchamiania programu kwantowego zestaw QDK tworzy wystąpienie symulatora kwantowego i przekazuje Q# do niego kod. Symulator używa kodu Q# do tworzenia kubitów (symulacji cząstek kwantowych) i stosuje przekształcenia w celu zmodyfikowania ich stanu. Wyniki operacji kwantowych w symulatorze są następnie zwracane do programu. Odizolowanie kodu Q# w symulatorze gwarantuje, że algorytmy są zgodne z prawami fizyki kwantowej i mogą działać poprawnie na komputerach kwantowych.

Przesyłanie programu do rzeczywistego sprzętu kwantowego

Programy (znane również jako zadania) można przesyłać Q# do usługi Azure Quantum za pomocą preferowanego środowiska deweloperskiego zarówno lokalnie, jak i w trybie online. Aby uzyskać więcej informacji, zobacz jak przesyłać Q# zadania. Można również uruchamiać i przesyłać obwody kwantowe napisane w językach Qiskit i Cirq.

Usługa Azure Quantum oferuje obecnie najbardziej atrakcyjny i zróżnicowany sprzęt kwantowy dostępny od liderów branży. Zobacz Dostawcy obliczeń kwantowych, aby uzyskać bieżącą listę obsługiwanych dostawców sprzętu.

Na poniższym diagramie przedstawiono podstawowy przepływ pracy po przesłaniu zadania:

Powiązana zawartość

• Różne sposoby uruchamiania Q# programów
• Konfigurowanie zestawu Quantum Development Kit
• Szybki start: tworzenie pierwszego Q# programu