A kvantumprogramozási nyelv bemutatása Q#

👉 További információ a Microsoft Quantum platformról

Q# egy magas szintű, nyílt forráskódú programozási nyelv, amelyet a Microsoft fejlesztett ki kvantumprogramok írásához. Q# a Microsoft Quantum Development Kit (QDK) része. További információ: A Microsoft Quantum Development Kit beállítása.

Kvantumprogramozási nyelvként Q# megfelel a nyelvre, a fordítóra és a futtatókörnyezetre vonatkozó alábbi követelményeknek:

• Hardver agnosztikus: A kvantum-algoritmusokban lévő qubitek nincsenek egy adott kvantumhardverhez vagy elrendezéshez kötve. A Q# fordító és futtatókörnyezet kezeli a program qubitjeiről a fizikai qubitekre való leképezést, így ugyanazt a kódot különböző kvantumprocesszorokon futtathatja.
• kvantum- és klasszikus számítástechnika integrálása: aQ# lehetővé teszi a kvantum- és klasszikus számítások integrálását, amely elengedhetetlen az univerzális kvantum-számítástechnikához.
• Qubit-kezelés: aQ# beépített műveleteket és funkciókat biztosít a qubitek kezeléséhez, beleértve a szuperpozíciós állapotok létrehozását, a qubitek összefonódását és a kvantumméréseket.
• A fizika törvényeinek tiszteletben tartása: aQ# és a kvantum-algoritmusoknak be kell tartaniuk a kvantumfizika szabályait. Például nem másolhatja vagy nem érheti el közvetlenül a qubit állapotát a fájlban Q#.

A Q#eredetéről további információért tekintse meg a Miért van szükségünk Q#?című blogbejegyzést.

A Q# program felépítése

Mielőtt elkezdené írni Q# programokat, fontos megérteni azok szerkezetét és összetevőit. Vegye figyelembe a következő Q# , névvel ellátott Superpositionprogramot, amely szuperpozíciós állapotot hoz létre:

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

A megjegyzések (//) alapján a Q# program először lefoglal egy qubitet, egy műveletet alkalmaz a qubit szuperpozícióba helyezéséhez, méri a qubit állapotát, alaphelyzetbe állítja a qubitet, és végül visszaadja az eredményt.

Bontsuk le ezt a Q# programot az összetevőire.

Felhasználónévterek

Q# programok igény szerint egy felhasználó által definiált névtérrel kezdődhetnek, például:

namespace Superposition {
    // Your code goes here.
}

A névterek segíthetnek a kapcsolódó funkciók rendszerezésében. A névterek nem kötelezőek a programokban Q# , ami azt jelenti, hogy névtér definiálása nélkül is írhat programokat.

A példában szereplő program például Superposition névtér nélkül is írható a következő módon:

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

Feljegyzés

Minden Q# programnak csak egy namespacelehet . Ha nem ad meg névteret, a Q# fordító a fájlnevet használja névtérként.

Belépési pontok

Minden Q# programnak rendelkeznie kell egy belépési ponttal, amely a program kiindulópontja. Alapértelmezés szerint a Q# fordító elindít egy programot a Main() műveletből, ha van ilyen, amely a program bármely pontján elhelyezhető. Opcionálisan használhatja a @EntryPoint() attribútumot, hogy megadjon bármely műveletet a programban a végrehajtás pontjaként.

A programban például a Superposition programban a MeasureOneQubit() művelet a program belépési pontja, mert a @EntryPoint() attribútum a művelet definíciója előtt található.

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

A program azonban a @EntryPoint() attribútum nélkül is írható, ha átnevezi a MeasureOneQubit() műveletet Main(), például:

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

Típusok

A típusok minden programozási nyelvben nélkülözhetetlenek, mivel meghatározzák azokat az adatokat, amelyekkel a program dolgozhat. A Q# olyan beépített típusokat biztosít, amelyek a legtöbb nyelvre jellemzőek, beleértve a Int, a Double, a Boolés a String, valamint a tartományokat, tömböket és tupleseket meghatározó típusokat.

Q# a kvantum-számítástechnikára jellemző típusokat is biztosít. A Result típus például egy qubitmérés eredményét jelöli, és két értékkel rendelkezhet: Zero vagy One.

A programban a SuperpositionMeasureOneQubit() művelet egy típust Result ad vissza, amely megfelel a M művelet visszatérési típusának. A mérési eredmény egy új változóban lesz tárolva, amely a let következő utasítással van definiálva:

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

Egy kvantumspecifikus típusra egy másik példa a Qubit típus, amely egy kvantumbitet jelöl.

Q# saját egyéni típusokat is definiálhat. További információ: Típusdeklarációk.

A qubitek kiosztása

A Q#-ban a qubiteket a use kulcsszó és a Qubit típus segítségével osztja ki. A qubitek mindig az $\ket{0}$ állapotban vannak kiosztva.

A program például egyetlen qubitet határoz meg, Superposition és a változóban qtárolja:

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

Több qubitet is lefoglalhat, és mindegyiket az indexén keresztül érheti el:

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.

Kvantumműveletek

A qubitek kiosztása után átadhatja azt a műveleteknek és függvényeknek. A műveletek a Q# program alapvető építőelemei. A Q# művelet egy kvantum-alrutin, vagy egy hívható rutin, amely olyan kvantumműveleteket tartalmaz, amelyek megváltoztatják a qubit-regiszter állapotát.

Egy Q# művelet definiálásához meg kell adnia a művelet nevét, bemeneteit és kimenetét. A programban a SuperpositionMeasureOneQubit() művelet nem vesz fel paramétereket, és egy típust Result ad vissza:

operation MeasureOneQubit() : Result {
    ...
}

Íme egy egyszerű példa, amely nem vesz fel paramétereket, és nem számít visszatérési értékre. Az Unit érték más nyelveken egyenértékű NULL :

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

A Q# standard kódtár olyan műveleteket is biztosít, amelyeket kvantumprogramokban, például a Hadamard műveletben His használhat a Superposition programban. Egy Z-bázisú qubit esetén a H a qubitet egyenletes szuperpozícióba helyezi, ahol 50%-os eséllyel mérhető Zero vagy One állapotként.

Qubitek mérése

Bár a kvantummérések számos típusa létezik, Q# a projektív mérésekre összpontosít az önálló qubiteken, más néven Pauli-méréseken.

A Q#művelet egy Measure vagy több qubitet mér a megadott Pauli-alapon, amely lehet PauliX, PauliYvagy PauliZ. Measure egy vagy több típust ResultZeroOnead vissza.

A számítási alapban $\lbrace\ket{0},\ket{1}\rbrace$ történő mérés végrehajtásához használhatja a M műveletet is, amely egy qubitet mér a Pauli Z-alapban. Ez teszi M egyenértékűvé Measure([PauliZ], [qubit])-el.

A Superposition program például a M műveletet használja:

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

Qubitek alaphelyzetbe állítása

A Q# qubiteknek állapotban kell lenniük, amikor kiengedik őket, a kvantumhardver hibáinak elkerülése érdekében. A qubiteket a program végén található $\ket{0}$ művelettel állíthatja vissza a Reset állapotba. A qubit alaphelyzetbe állításának sikertelensége futásidejű hibát eredményez.

// Reset a qubit.
Reset(q);

Standard könyvtárnévterek

A Q# standard kódtár beépített névterekkel rendelkezik, amelyek kvantumprogramokban használható függvényeket és műveleteket tartalmaznak. A névtér például Std.Intrinsic gyakran használt műveleteket és függvényeket tartalmaz, például M az eredmények mérésére és Message a felhasználói üzenetek megjelenítésére a programban bárhol.

Egy függvény vagy művelet meghívásához megadhatja a teljes névteret, vagy használhat egy utasítást import , amely elérhetővé teszi az adott névtér összes függvényét és műveletét, és olvashatóbbá teszi a kódot. Az alábbi példák ugyanazt a műveletet hívják:

Std.Intrinsic.Message("Hello quantum world!");

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

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

Feljegyzés

A Superposition program nem rendelkezik teljes import névtérrel rendelkező utasításokkal vagy hívásokkal. Ennek az az oka, hogy a Q# fejlesztői környezet automatikusan betölt két névteret, Std.Core és Std.Intrinsicamelyek gyakran használt függvényeket és műveleteket tartalmaznak.

A Std.Measurement program optimalizálásához kihasználhatja a MResetZ névteret a Superposition művelet segítségével. MResetZ a mérési és alaphelyzetbe állítási műveleteket egyetlen lépésben egyesíti, ahogyan az alábbi példában is látható:

// Import the namespace for the MResetZ operation.
import Std.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);
}

Kvantumprogramok fejlesztése a Q# és az Azure Quantum használatával

Q# és az Azure Quantum hatékony kombináció a kvantumprogramok fejlesztéséhez és futtatásához. Az Azure Quantum használatával Q# kvantumprogramokat írhat, szimulálhatja a viselkedésüket, megbecsülheti az erőforrásigényeket, és valós kvantumhardveren futtathatja őket. Ez az integráció lehetővé teszi, hogy feltárja a kvantum-számítástechnika lehetőségeit, és innovatív megoldásokat fejlesszen ki összetett problémákra. Akár kezdő, akár tapasztalt kvantumfejlesztő, Q# az Azure Quantum biztosítja azokat az eszközöket és erőforrásokat, amelyekre szüksége van a kvantum-számítástechnika erejének kiaknázásához.

Az alábbi ábra bemutatja azokat a fázisokat, amelyeken keresztülhalad egy kvantumprogram, amikor Q#-t és az Azure Quantumot használja a fejlesztéséhez. A program a fejlesztési környezettel kezdődik, és a feladat valódi kvantumhardverbe való beküldésével fejeződik be.

Bontjuk le a diagramot lépéseit.

A fejlesztőkörnyezet kiválasztása

A kvantumprogramokat az előnyben részesített fejlesztési környezetben futtathatja. Használhat egy helyi fejlesztési környezetet a Visual Studio Code-dal, vagy együtt használhatja a Q# kódot Python-kóddal a Jupyter Notebookban. További információ: Programok futtatásának Q#különböző módjai.

A kvantumprogram írása

Kvantumprogramokat írhat a QDK használatával Q#. Első lépésként tekintse meg a rövid útmutatót: Az első Q# program létrehozása.

Q#Emellett a QDK más kvantum-számítástechnika nyelveket is támogat, például a Qiskitet és a Cirqot.

Integrálás a Pythonnal

Használhatja a Q#-t önmagában, vagy a Pythonnal együtt a különböző IDE-kben. Használhat például egy Q# projektet egy Python-gazdaprogrammal Q# műveletek meghívására, vagy a Q# a Pythonnal való integrálására a Jupyter Notebooksban. További információ: Q# és Pythonintegrációja.

A %%qsharp parancs

Alapértelmezés szerint a Q# Jupyter notebookokban lévő programok a Python-csomagot ipykernel használják. Használja a Q# parancsot, amely a %%qsharp Python csomag része, hogy qsharp kódot adjon egy jegyzetfüzetcellához, majd adja hozzá a Q# kódot.

Használat során, %%qsharp tartsa szem előtt az alábbiakat:

• Először a from qdk import qsharp futtatása szükséges a %%qsharp engedélyezéséhez.
• %%qsharp rámutat arra a jegyzetfüzetcellára, amelyben megjelenik, és a cellatípust Pythonról Q#-ra módosítja.
• A Python-utasítás nem helyezhető el előtte vagy utána %%qsharp.
• Q# kódnak, amely követi %%qsharp, meg kell felelnie a Q# szintaxisnak. Használja például a //-t a # helyett a megjegyzések jelölésére és a ;-et kódsorok lezárására.

Erőforráskövetelmények becslése

Mielőtt valódi kvantumhardveren futna, ki kell derítenie, hogy a program futtatható-e meglévő hardveren, és hogy a program hány erőforrást fog használni.

A Microsoft Kvantumerőforrás-becslés lehetővé teszi az architekturális döntések értékelését, a qubit-technológiák összehasonlítását és az adott kvantumalkalmazás futtatásához szükséges erőforrások meghatározását. Választhat az előre definiált hibatűrő protokollok közül, és megadhatja a mögöttes fizikai qubitmodell feltételezéseit.

Első lépésként tekintse meg a Microsoft Quantum-erőforrásbecslő telepítését és használatát ismertető témakört.

Feljegyzés

A Microsoft Quantum-erőforrásbecslő szabadon használható, és nem igényel Azure fiókot.

A program futtatása szimulációban

Kvantumprogram lefordításakor és futtatásakor a QDK létrehozza a kvantumszimulátor egy példányát, és átadja neki a Q# kódot. A szimulátor a Q#-kóddal hoz létre qubiteket (kvantumrészecskék szimulációit), és átalakításokat alkalmaz az állapotuk módosításához. A rendszer ezután visszaadja a programnak a kvantumműveletek eredményeit. A Q#-kód a szimulátoron belüli elkülönítése biztosítja, hogy az algoritmusok kövessék a kvantumfizika törvényeit, és megfelelően fussanak a kvantumszámítógépeken.

A program beküldése valós kvantumhardverbe

Miután tesztelte a programot szimulációban, valós kvantumhardveren futtathatja. Amikor kvantumprogramot futtat az Azure Quantumban, létrehoz és futtat egy feladatot. Ahhoz, hogy feladatot küldjön az Azure Quantum-szolgáltatóknak, szüksége van egy Azure-fiókra és egy kvantum-munkaterületre. Ha nincs kvantum-munkaterülete, olvassa el az Azure Quantum-munkaterület létrehozása című témakört.

Az Azure Quantum a legvonzóbb és legváltozatosabb kvantumhardvereket kínálja. A támogatott hardverszolgáltatók aktuális listájáért tekintse meg a Kvantum-számítástechnika-szolgáltatókat .

A feladat elküldése után az Azure Quantum felügyeli a feladat életciklusát, beleértve a feladatütemezést, a végrehajtást és a figyelést. Nyomon követheti a feladat állapotát, és megtekintheti az eredményeket az Azure Quantum Portalon.

Kapcsolódó tartalom

• Programok futtatásának Q# különböző módjai
• Microsoft Quantum Development Kit beállítása
• Rövid útmutató: Az első Q# program létrehozása

👉 További információ a Microsoft Quantum platformról