Megosztás a következőn keresztül:

A kvantumprogramozási nyelv bemutatása Q#

Q# egy magas szintű, nyílt forráskódú programozási nyelv, amelyet a Microsoft fejlesztett ki kvantumprogramok írásához. Q# A Quantum Development Kit (QDK) része. További információért lásd: A 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 az alábbi, Superpositionnevű 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 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 Q# programokban, ami azt jelenti, hogy névtér definiálása nélkül is írhat programokat.

A példa Superposition programja például névtér nélkül is írható, például:

@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 Superposition programban például a MeasureOneQubit() művelet a program belépési pontja, mert a műveletdefiníció előtt a @EntryPoint() attribútummal rendelkezik:

@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 Superposition programban a MeasureOneQubit() művelet egy Result típust 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 Superposition program például egyetlen qubitet határoz meg, és a qváltozóban tá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 Superposition programban a MeasureOneQubit() művelet nem vesz fel paramétereket, és Result típust 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. 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#a qubiteknek $\ket{0}$ állapotban kell lenniük a kvantumhardver hibáinak elkerülése érdekében. A qubiteket a program végén található Reset művelettel állíthatja vissza a $\ket{0}$ á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 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!");

Feljegyzés

A Superposition program nem rendelkezik teljes névtérrel rendelkező import 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 Microsoft.Quantum.Measurement névtér kihasználása érdekében a MResetZ művelettel optimalizálhatja a Superposition programot. 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 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.

A kvantumprogramozási fejlesztés munkafolyamatát bemutató ábra.

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

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 %%qsharp parancsot, amely a qsharp Python csomag része, hogy Q# 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 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á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.

Feljegyzés

Az Azure Quantum Resources Estimator ingyenes, é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