Megjegyzés
Az oldalhoz való hozzáféréshez engedély szükséges. Megpróbálhat bejelentkezni vagy módosítani a címtárat.
Az oldalhoz való hozzáféréshez engedély szükséges. Megpróbálhatja módosítani a címtárat.
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 namespace
lehet . 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 q
vá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 H
is 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
, PauliY
vagy PauliZ
.
Measure
egy vagy több típust Result
Zero
One
ad 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.Intrinsic
amelyek 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.
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.