A kvantumprogramozási nyelv bemutatása Q#

Q# egy magas szintű, nyílt forráskódú programozási nyelv kvantum-algoritmusok fejlesztéséhez és futtatásához. Q# A Quantum Development Kit (QDK) része. További információ: A Quantum Development Kit beállítása.

Kvantumprogramozási nyelvként Q# megfelel a következő nyelvi, fordítói és futtatókörnyezeti 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 a futtatókörnyezet kezeli a program qubitjeiről a fizikai qubitekre való leképezést.
• Integrálja a kvantum- és klasszikus számítástechnikát: A klasszikus és kvantumszámítások végrehajtásának képessége alapvető fontosságú egy univerzális kvantumszámítógépen.
• Tiszteletben tartja a fizika törvényeit:Q# a kvantum-algoritmusok pedig a kvantumfizika szabályait követik. Például nem másolhatja vagy nem érheti el közvetlenül a qubit állapotát a fájlban Q#.

A Q# program felépítése

Mielőtt elkezdene kvantumprogramokat írni, fontos megérteni azok szerkezetét és összetevőit. Fontolja meg az alábbi Q# programot, 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 Superposition 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 a programot az összetevőire.

Felhasználónévterek

Q# a 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. Minden Q# programnak csak egy namespacelehet . Ha nincs megadva névtér, a fordító a Q# fájlnevet használja névtérként. A program például a Superposition következőképpen írható:

@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 Q# standard kódtár előre definiált névterekkel rendelkezik, amelyek kvantumprogramokban használható függvényeket és műveleteket tartalmaznak. További információ: Beépített névterek.

Belépési pontok

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ő. Az attribútum használatával @EntryPoint() a program bármely műveletét megadhatja végrehajtási pontként.

Superposition A programban a leíróbb MeasureOneQubit() művelet a program belépési pontja.

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

A program azonban attribútum @EntryPoint() nélkül is írható úgy, hogy a műveletet a MeasureOneQubit() következőre Main()átnevezi:

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

Q# Beépített típusok, amelyek a legtöbb nyelv esetében gyakoriak, beleértve Inta kvantum-számítástechnikára DoubleBoolStringjellemző típusokat is. A típus például egy qubitmérés eredményét jelöli, Result és két érték egyikével 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);
    ...

Q# olyan típusokat is tartalmaz, amelyek tartományokat, tömböket és halmazokat határoznak meg. Saját egyéni típusokat is meghatározhat.

A qubitek lefoglalása

Ebben a fájlban Q#qubiteket foglal le a use kulcsszó használatával. A qubitek mindig az $\ket{0}$ állapotban vannak lefoglalva.

A Superposition program egyetlen qubitet határoz meg:

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

További információ: Használati utasítás.

Kvantumműveletek

A qubitek kiosztása után átadhatja azokat a műveleteknek és függvényeknek, más néven hívható függvényeknek. A műveletek a program alapvető építőelemei Q# . 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 lényegében a teljes program. 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 a kvantumprogramokban, például a Hadamard műveletben His használható műveleteket biztosít a Superposition programban. A Z-alapot H figyelembe véve a qubitet egyenletes szuperpozícióba helyezi, ahol 50%-os eséllyel mérik, mint Zero vagy One.

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 \lbrace,$\rbrace\ket{0}\ket{1} számítási alapban $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 egyenértékűvé teszi M a következőt Measure([PauliZ], [qubit]): .

A Superposition program a M következő műveletet használja:

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

Qubitek alaphelyzetbe állítása

Ebben Q#az esetben a qubiteknek $\ket{0}$ lenniük. A művelettel Reset állítsa vissza az egyes qubiteket az $\ket{0}$ állapotra, mielőtt a program végén felszabadítja azt. A qubit alaphelyzetbe állításának sikertelensége futásidejű hibát eredményez.

// Reset a qubit.
Reset(q);

Beépített né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 Microsoft.Quantum.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:

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

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, Microsoft.Quantum.Core és Microsoft.Quantum.Intrinsicamelyek gyakran használt függvényeket és műveleteket tartalmaznak.

A program optimalizálásához a művelettel kihasználhatja Microsoft.Quantum.Measurement a névteretMResetZ.Superposition 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 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);
}

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

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 azokat a fázisokat mutatja be, amelyeken keresztül egy kvantumprogram halad át, amikor fejleszti azt és az Azure Quantumot Q# . A program a fejlesztési környezettel kezdődik, és a feladat valódi kvantumhardverbe való beküldésével fejeződik be.

Bontsuk le a diagram lépéseit.

A fejlesztőkörnyezet kiválasztása

A kvantumprogramokat az előnyben részesített fejlesztési környezetben futtathatja. Használhatja az online kódszerkesztőt az Azure Quantum webhelyén, a üzemeltetett Jupyter Notebookokat az Azure Quantum-munkaterületen az Azure Portalon, vagy egy helyi fejlesztési környezetet a Visual Studio Code-tal. További információ: Programok futtatásának Q#különböző módjai.

A kvantumprogram írása

Kvantumprogramokat Q# a Quantum Development Kit (QDK) használatával írhat. 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

Q# Használhatja önmagában vagy a Pythonnal együtt a különböző azonosítókban. A projekteket például egy Python-gazdaprogrammal is meghívhatja Q# a műveletek meghívásához.Q# A Pythonnal a Jupyter Notebooksban is integrálható Q# . További információ: Programok futtatásának Q#különböző módjai.

A %%qsharp parancs

Alapértelmezés szerint a Q# Jupyter notebookokban lévő programok a Python-csomagot ipykernel használják. Ha kódot szeretne hozzáadni Q# egy jegyzetfüzetcellához, használja a %%qsharp Python-csomaggal qsharp engedélyezett parancsot, majd a Q# kódot.

A használat %%qsharpsorán tartsa szem előtt az alábbiakat:

• Először futnia import qsharp kell az engedélyezéshez %%qsharp.
• %%qsharp hatókörök arra a jegyzetfüzetcellára, amelyben megjelenik, és a pythonról a következőre módosítja a cellatípust Q#: .
• A Python-utasítás nem helyezhető el előtte vagy utána %%qsharp.
• Q# az alábbi kódnak meg kell felelnie %%qsharp a szintaxisnak Q# . Használhatja például ahelyett, //# hogy megjegyzéseket és ; kódsorokat jelöljön.

Erőforrások becslése

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

Az Azure Quantum Resource Estimator 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 kvantum-algoritmus végrehajtá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.

További információ: Az első erőforrás-becslés futtatása.

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

A programokat (más néven feladatokat) elküldheti az Q# Azure Quantumnak az előnyben részesített fejlesztési környezeten keresztül, helyileg és online is. További információ: Q# elküldése. Qiskit és Cirq nyelven írt kvantum áramköröket is futtathat és küldhet el.

Az Azure Quantum az iparági vezetők által ma elérhető legkülönfélébb és legkülönfélébb 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 .

Az alábbi ábra a feladat elküldése utáni alapszintű munkafolyamatot mutatja be:

Kapcsolódó tartalom

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