Úvod do kvantového programovacího jazyka Q#

Q# je vysoce opensourcový programovací jazyk pro vývoj od Microsoftu pro psaní kvantových programů. Q# je součástí sady Quantum Development Kit (QDK). Další informace najdete v tématu Nastavení sady Quantum Development Kit.

Jako kvantový programovací jazyk Q# splňuje následující požadavky pro jazyk, kompilátor a modul runtime:

• Nezávislá na hardwaru: Qubity v kvantových algoritmech nejsou svázané s konkrétním kvantovým hardwarem nebo rozložením. Kompilátor Q# a modul runtime zpracovávají mapování z qubitů programu na fyzické qubity, což umožňuje, aby stejný kód běžel na různých kvantových procesorech.
• Integrace kvantových a klasických výpočtů:Q# umožňuje integraci kvantových a klasických výpočtů, což je nezbytné pro univerzální kvantové výpočty.
• správa Qubitu:Q# poskytuje integrované operace a funkce pro správu qubitů, včetně vytváření stavů superpozice, propletení qubitů a provádění kvantových měření.
• Respektovat zákony fyziky:Q# a kvantové algoritmy musí dodržovat pravidla kvantové fyziky. Například nemůžete přímo kopírovat nebo přistupovat ke stavu qubitu v Q#.

Další informace o původu Q#naleznete v blogovém příspěvku Proč potřebujeme Q#?.

Q# Struktura programu

Než začnete psát Q# programy, je důležité porozumět jejich struktuře a komponentám. Zvažte následující Q# program s názvem superpozice, který vytvoří stav superpozice:

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 základě komentářů (//), Q# program nejprve přidělí qubit, použije operaci, která umístí qubit do superpozice, měří stav qubitu, resetuje qubit a nakonec vrátí výsledek.

Pojďme tento Q# program rozdělit do jeho součástí.

Obory názvů uživatelů

Q# programy můžou volitelně začínat uživatelem definovaným oborem názvů, například:

namespace Superposition {
    // Your code goes here.
}

Obory názvů vám můžou pomoct uspořádat související funkce. Nepovinné obory názvů jsou v programech Q#, což znamená, že program můžete psát bez definování oboru názvů.

Například superpozice programu tohoto příkladu může být napsána i bez oboru názvů 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;
}

Vstupní body

Každý program Q# musí mít vstupní bod, což je výchozí bod programu. Ve výchozím nastavení Q# kompilátor spustí program z Main() operace, pokud je k dispozici, který může být umístěn kdekoli v programu. Volitelně můžete pomocí atributu @EntryPoint() určit jakoukoli operaci v programu jako bod provádění.

Například v programu superpozice je operace MeasureOneQubit() vstupním bodem programu, protože má před definicí operace atribut @EntryPoint():

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

Program však může být také zapsán bez atributu @EntryPoint() přejmenováním operace MeasureOneQubit() na Main(), například:

// 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

Typy jsou nezbytné v jakémkoli programovacím jazyce, protože definují data, se kterými může program pracovat. Q# poskytuje předdefinované typy, které jsou společné pro většinu jazyků, včetně Int, Double, Boola String, a typů definujících rozsahy, pole a třídy.

Q# také poskytuje typy, které jsou specifické pro kvantové výpočty. Například typ Result představuje výsledek měření qubitu a může mít dvě hodnoty: Zero nebo One.

V programu Superposition vrátí operace MeasureOneQubit() typ Result, který odpovídá návratovému typu operace M. Výsledek měření se uloží do nové proměnné, která je definovaná pomocí let příkazu:

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

Dalším příkladem kvantového typu je typ Qubit, který představuje kvantový bit.

Q# také umožňuje definovat vlastní typy. Další informace naleznete v tématu Deklarace typů.

Přidělování qubitů

V Q#přidělíte qubity pomocí klíčového slova use a typu Qubit. Qubity se vždy přidělují ve $\ket{0}$ stavu.

Například program superpozice definuje jeden qubit a uloží ho do proměnné q:

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

Můžete také přidělit více qubitů a přistupovat k jednotlivým qubitům prostřednictvím jeho indexu:

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.

Další informace naleznete v tématu Příkaz Use.

Kvantové operace

Po přidělení qubitu ho můžete předat operacím a funkcím. Operace jsou základní stavební bloky Q# programu. Operace Q# je kvantový podprogram nebo volatelná rutina, která obsahuje kvantové operace, které mění stav registru qubitu.

Pokud chcete definovat Q# operaci, zadáte název operace, její vstupy a výstup. V programu superpozice operace MeasureOneQubit() nepřijímá žádné parametry a vrací typ Result:

operation MeasureOneQubit() : Result {
    ...
}

Tady je základní příklad, který nepřijímá žádné parametry a neočekává žádnou návratovou hodnotu. Hodnota Unit je ekvivalentní NULL v jiných jazycích:

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

Standardní Q# knihovna také poskytuje operace, které můžete použít v kvantových programech, jako je operace Hadamard, Hv Superposition programu. Vzhledem k qubitu v základu H Z umístí qubit do sudé superpozice, kde má 50% šanci změřit jako Zero nebo One.

Měření qubitů

I když existuje mnoho typů kvantových měření, Q# zaměřuje se na projektová měření na jednotlivých qubitech, označovaných také jako pauliová měření.

Operace Q#Measure měří jeden nebo více qubitů v zadaném základu Pauli, který může být PauliX, PauliYnebo PauliZ. Measure Result vrátí typ nebo ZeroOne.

K implementaci měření ve výpočetním základu $\lbrace\ket{0},\ket{1}\rbrace$ můžete také použít M operaci, která měří qubit v základu Pauli Z. To činí M ekvivalentem Measure([PauliZ], [qubit]).

Například program superpozice používá operaci M:

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

Resetování qubitů

Ve stavu $\ket{0}$ v Q#musí qubity být, když jsou uvolněny, aby se zabránilo chybám v kvantovém hardwaru. Qubit můžete resetovat do $\ket{0}$ stavu pomocí operace Reset na konci programu. Při resetování qubitu dojde k chybě za běhu.

// Reset a qubit.
Reset(q);

Obory názvů standardní knihovny

Standardní Q# knihovna má integrované obory názvů, které obsahují funkce a operace, které můžete použít v kvantových programech. Obor názvů například Microsoft.Quantum.Intrinsic obsahuje běžně používané operace a funkce, jako M je měření výsledků a Message zobrazení uživatelských zpráv kdekoli v programu.

Chcete-li volat funkci nebo operaci, můžete zadat úplný obor názvů nebo použít import příkaz, který zpřístupňuje všechny funkce a operace pro tento obor názvů a usnadňuje čtení kódu. Následující příklady volají stejnou operaci:

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

Obor názvů Microsoft.Quantum.Measurement můžete využít pomocí operace MResetZ k optimalizaci programu superpozice. MResetZ kombinuje operace měření a resetování do jednoho kroku, jak je znázorněno v následujícím příkladu:

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

Naučte se vyvíjet kvantové programy pomocí Q# a Azure Quantum.

Q# a Azure Quantum představují výkonnou kombinaci pro vývoj a spouštění kvantových programů. S Q# Azure Quantum můžete psát kvantové programy, simulovat jejich chování, odhadnout požadavky na prostředky a spouštět je na skutečném kvantovém hardwaru. Tato integrace vám umožní prozkoumat potenciál kvantových výpočtů a vyvíjet inovativní řešení složitých problémů. Ať už jste začátečník nebo zkušený kvantový vývojář, Q# a Azure Quantum poskytuje nástroje a prostředky, které potřebujete k odemknutí výkonu kvantových výpočtů.

Následující diagram znázorňuje fáze, kterými kvantový program prochází při vývoji pomocí Q# Azure Quantum. Váš program začíná vývojovým prostředím a končí odesláním úlohy do skutečného kvantového hardwaru.

Pojďme si rozdělit kroky v diagramu.

Volba vývojového prostředí

Spusťte kvantové programy ve vašem upřednostňovaném vývojovém prostředí. Online editor kódu můžete použít na webu Azure Quantum, hostované poznámkové bloky Jupyter v pracovním prostoru Azure Quantum na webu Azure Portal nebo místní vývojové prostředí pomocí editoru Visual Studio Code. Další informace naleznete v tématu Různé způsoby spouštění Q# programů.

Psaní kvantového programu

Kvantové programy můžete psát pomocí Q# sady Quantum Development Kit (QDK). Pokud chcete začít, přečtěte si článek Rychlý start: Vytvoření prvního Q# programu.

Kromě toho Q#QDK nabízí podporu pro další jazyky pro kvantové výpočty, jako je Qiskit a Cirq.

Integrace s Pythonem

V různých prostředích IDEs můžete používat Q# samostatně nebo společně s Pythonem. Můžete například použít projekt Q# s hostitelským programem Pythonu k volání Q# operací nebo integraci Q# s Pythonem v Poznámkových blocích Jupyter. Další informace najdete v tématu Integrace Q# a Pythonu.

Příkaz %%qsharp

Ve výchozím nastavení Q# používají programy v Poznámkových blocích ipykernel Jupyter Balíček Pythonu. Pokud chcete do buňky poznámkového bloku přidat Q# kód, použijte %%qsharp příkaz, který je povolený s balíčkem qsharp Pythonu a za ním váš Q# kód.

Při použití %%qsharpmějte na paměti následující skutečnosti:

• Nejprve je nutné spustit import qsharp , aby bylo možné povolit %%qsharp.
• %%qsharp obory na buňku poznámkového bloku, ve které se zobrazí, a změní typ buňky z Pythonu na Q#.
• Příkaz Pythonu nelze vložit před nebo za %%qsharp.
• Q# kód, který následuje %%qsharp , musí dodržovat Q# syntaxi. Použijte například // místo # k označení komentářů a ; ke konci řádků kódu.

Odhad prostředků

Než začnete používat skutečný kvantový hardware, musíte zjistit, jestli váš program může běžet na existujícím hardwaru a kolik prostředků bude spotřebovávat.

Estimátor prostředků Azure Quantum umožňuje vyhodnotit rozhodnutí o architektuře, porovnat technologie qubitu a určit prostředky potřebné k provedení daného kvantového algoritmu. Můžete si vybrat z předem definovaných protokolů odolných proti chybám a zadat předpoklady základního fyzického qubitového modelu.

Další informace najdete v tématu Spuštění prvního odhadu prostředků.

Spuštění programu v simulaci

Když zkompilujete a spustíte kvantový program, QDK vytvoří instanci kvantového simulátoru a předá Q# mu kód. Simulátor podle kódu Q# vytvoří simulované qubity a podle zadaných transformací bude manipulovat s jejich stavy. Výsledky kvantových operací ze simulátoru se pak vrátí do programu. Izolování kódu Q# v simulátoru zajišťuje, že algoritmy budou odpovídat zákonům kvantové fyziky a budou správně fungovat i na kvantových počítačích.

Odeslání programu do skutečného kvantového hardwaru

Své Q# programy můžete odeslat do Azure Quantum, aby běžely na skutečném kvantovém hardwaru. Můžete také spouštět a odesílat kvantové okruhy napsané v jazycích Qiskit a Cirq. Při spuštění kvantového programu v Azure Quantum vytvoříte a spustíte úlohu. Další informace najdete v tématu odesílání programů Q# do služby Azure Quantum.

xref:microsoft.quantum.work-with-jobs

Azure Quantum nabízí některé z nejúraznějších a různorodých kvantových hardwarů, které jsou dnes k dispozici od předních oborů. Aktuální seznam podporovaných poskytovatelů hardwaru najdete v tématu Poskytovatelé kvantových výpočtů.

Jakmile úlohu odešlete, Azure Quantum spravuje životní cyklus úlohy, včetně plánování, spouštění a monitorování úloh. Stav úlohy můžete sledovat a zobrazit výsledky na portálu Azure Quantum. Další informace najdete v tématu Práce s úlohami Azure Quantum.

Související obsah

• Různé způsoby spouštění Q# programů
• Nastavení sady Quantum Development Kit
• Rychlý start: Vytvoření prvního Q# programu