Udostępnij za pośrednictwem


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.

Diagram przedstawiający przepływ pracy programowania 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.

Uwaga

Notesy platformy Azure w witrynie Azure Portal zawierają najnowsze wersje qsharp pakietów i azure-quantum Python, więc nie trzeba instalować żadnych elementów. Aby uzyskać więcej informacji, zobacz Get started with and Azure Quantum notebooks (Wprowadzenie do Q# notesów usługi Azure Quantum).

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.

Uwaga

Narzędzie do szacowania zasobów usługi Azure Quantum jest bezpłatne i nie wymaga konta platformy Azure.

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.

Uwaga

Obiekt docelowy Quantinuum Emulator oparty na chmurze jest dostępny bez konta platformy Azure. Aby przesłać zadanie do pozostałych dostawców usługi Azure Quantum, potrzebujesz konta platformy Azure i obszaru roboczego kwantowego. Jeśli nie masz obszaru roboczego kwantowego, zobacz Tworzenie obszaru roboczego usługi Azure Quantum.

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

Diagram przedstawiający przepływ pracy po przesłaniu zadania do usługi Azure Quantum.