Oktatóanyag: A Quantum Fourier-átalakítás implementálása Q#

Cikk
04/24/2024

Megjegyzés

A Microsoft Quantum Development Kit (klasszikus QDK) 2024. június 30. után már nem támogatott. Ha Ön már QDK-fejlesztő, javasoljuk, hogy váltson az új Azure-ra Quantum Development Kit (Modern QDK) a kvantummegoldások fejlesztésének folytatásához. További információ: A kód migrálása Q# a modern QDK-ba.

Ez az oktatóanyag bemutatja, hogyan írhat és szimulálhat egy alapszintű kvantumprogramot, amely az egyes qubiteken működik.

Bár Q# elsősorban nagy léptékű kvantumprogramok magas szintű programozási nyelveként hozták létre, a kvantumprogramozás alacsonyabb szintje, azaz az adott qubitek közvetlen kezelésére is használható. Ez az oktatóanyag közelebbről is megtekinti a Quantum Fourier Transform (QFT) nevű alrutint, amely számos nagyobb kvantum-algoritmus szerves része.

Ebből az oktatóanyagból az alábbiakat sajátíthatja el:

Kvantumműveletek definiálása a következőben: Q#.
A Quantum Fourier Transform-kapcsolatcsoport írása
Kvantumművelet szimulálása a qubit-foglalástól a mérési kimenetig.
Figyelje meg, hogyan fejlődik a kvantumrendszer szimulált hullámfüggvénye a művelet során.

Megjegyzés

A kvantuminformáció-feldolgozás ezen alacsonyabb szintű nézetét gyakran a kvantum-áramkörök írják le, amelyek a kapuk vagy műveletek szekvenciális alkalmazását jelölik egy rendszer adott qubitjeire. Így a szekvenciálisan alkalmazott egy- és több qubites műveletek könnyen megjeleníthetők a kapcsolatcsoportdiagramokban. Az oktatóanyagban használt teljes három qubites quantum Fourier-transzformáció például a következő kapcsolatcsoportot ábrázolja: Egy Quantum Fourier Transform-kapcsolatcsoport diagramja.

Tipp

Ha fel szeretné gyorsítani a kvantum-számítástechnika folyamatát, tekintse meg a Code with Azure Quantum (Kód az Azure Quantum használatával) című témakört, amely az Azure Quantum webhelyének egyedülálló funkciója. Itt futtathat beépített mintákat vagy saját Q# programokat, új Q# kódot hozhat létre az üzeneteiből, megnyithatja és futtathatja a kódot a WEBES VS Code-banQ# egy kattintással, és kérdéseket tehet fel a Copilotnak a kvantum-számítástechnikával kapcsolatban.

Előfeltételek

A Visual Studio Code legújabb verziója, vagy nyissa meg a VS Code-ot a weben.
Az Azure-bővítmény Quantum Development Kit legújabb verziója. A telepítés részleteiért lásd : A modern QDK telepítése a VS Code-on.
Ha Jupyter Notebookokat szeretne használni, telepítenie kell a Python- és Jupyter-bővítményeket , valamint a legújabb qsharp Python-csomagot is. Ehhez nyisson meg egy terminált, és futtassa a következő parancsot:
```
$ pip install --upgrade  qsharp
```

új Q# fájl Létrehozás

A VS Code-ban válassza az Új szövegfájl fájlja > lehetőséget
Mentse a fájlt QFTcircuit.qs néven. Ez a fájl tartalmazza a Q# program kódját.
Nyissa meg a QFTcircuit.qs fájlt.

QFT-kapcsolatcsoport írása Q#

Az oktatóanyag első része a Q# műveletet Perform3qubitQFThatározza meg, amely a kvantum Fourier-transzformációt három qubiten hajtja végre. A DumpMachine függvény annak megfigyelésére szolgál, hogyan fejlődik a három qubites rendszer szimulált hullámfüggvénye a művelet során. Az oktatóanyag második részében mérési funkciókat ad hozzá, és összehasonlítja a qubitek mérés előtti és utáni állapotát.

A műveletet lépésről lépésre fogja felépíteni. Másolja és illessze be a következő szakaszokban található kódot a QFTcircuit.qs fájlba.

A szakasz teljes Q# kódját hivatkozásként tekintheti meg.

Más műveletek eléréséhez szükséges Q# névterek

A fájlban Q# adja meg a névteret NamespaceQFT, amelyet a fordító ér el. Ahhoz, hogy a művelet meglévő Q# műveleteket használjon, nyissa meg a megfelelő Microsoft.Quantum.* névtereket.

namespace NamespaceQFT {
    open Microsoft.Quantum.Intrinsic;
    open Microsoft.Quantum.Diagnostics;
    open Microsoft.Quantum.Math;
    open Microsoft.Quantum.Arrays;

    // operations go here
}

Műveletek definiálása argumentumokkal és visszatérésekkel

Ezután adja meg a Perform3qubitQFT műveletet:

operation Perform3qubitQFT() : Unit {
    // do stuff
}

A művelet egyelőre nem vesz fel argumentumokat, és egy Unit olyan objektumot ad vissza, amely a C#-ban vagy egy üres rekordban a Tuple[()]Pythonban való visszatéréshez void hasonló. Később úgy módosítja a műveletet, hogy a mérési eredményeket tartalmazó tömböt adja vissza.

Qubitek lefoglalása

A műveleten Q# belül foglaljon le egy három qubitből álló regisztert a use kulcsszóval. A használatával usea qubitek automatikusan $\ket{0}$ állapotban lesznek lefoglalva.

use qs = Qubit[3]; // allocate three qubits

Message("Initial state |000>:");
DumpMachine();

A valós kvantumszámításokhoz hasonlóan nem teszi lehetővé a qubitállapotok Q# közvetlen elérését. A DumpMachine művelet azonban kinyomtatja a target gép aktuális állapotát, így értékes betekintést nyújthat a hibakereséshez és a tanuláshoz, ha a teljes állapotszimulátorsal együtt használják.

Egy qubites és szabályozott műveletek alkalmazása

Ezután alkalmazza azokat a műveleteket, amelyek magukban foglalják a Perform3qubitQFT műveletet. Q# már tartalmazza ezeket és sok más alapszintű kvantumműveletet a Microsoft.Quantum.Intrinsic névtérben.

Az első alkalmazott művelet a H (Hadamard) művelet az első qubitre:

Diagram a három qubites QFT-kapcsolatcsoportról az első Hadamardon keresztül.

Ha egy műveletet egy adott qubitre szeretne alkalmazni egy regiszterből (például egy Qubit tömbből Qubit[]), használjon szabványos indexjelet. Tehát a műveletet a H regiszter qs első qubitre való alkalmazása a következő formában történik:

H(qs[0]);

A művelet egyes qubitekre való alkalmazása H mellett a QFT-kapcsolatcsoport elsősorban szabályozott R1 rotációkból áll. Egy R1(θ, <qubit>) művelet általában változatlanul hagyja a qubit $\ket{0}$ összetevőjét, miközben $e^{i\theta}$ forgást alkalmaz a $\ket{1}$ összetevőre.

Q# megkönnyíti a műveletek futtatásának kondicionálódását egy vagy több vezérlési qubiten. Általában a hívás előtagja Controlleda , és a műveleti argumentumok az alábbiak szerint változnak:

Op(<normal args>) $\to$ Controlled Op([<control qubits>], (<normal args>))

Vegye figyelembe, hogy a vezérlő qubit argumentumának tömbnek kell lennie, még akkor is, ha egyetlen qubithez tartozik.

A QFT szabályozott műveletei az R1 első qubiten (és a második és a harmadik qubit által vezérelt) műveletek:

Diagram a három qubites Quantum Fourier Transform kapcsolatcsoportról az első qubiten keresztül.

A fájlban Q# hívja meg ezeket a műveleteket az alábbi utasításokkal:

Controlled R1([qs[1]], (PI()/2.0, qs[0]));
Controlled R1([qs[2]], (PI()/4.0, qs[0]));

A PI() függvény a pi radiánok forgásának meghatározására szolgál.

SWAP művelet alkalmazása

Miután a megfelelő H műveleteket és szabályozott forgatásokat alkalmazta a második és a harmadik qubitre, a kapcsolatcsoport a következőképpen néz ki:

//second qubit:
H(qs[1]);
Controlled R1([qs[2]], (PI()/2.0, qs[1]));

//third qubit:
H(qs[2]);

Végül egy műveletet alkalmaz SWAP az első és a harmadik qubitre a kapcsolatcsoport befejezéséhez. Erre azért van szükség, mert a quantum Fourier-transzformáció természete fordított sorrendben adja ki a qubiteket, így a felcserélések lehetővé teszik az alrutin nagyobb algoritmusokba való zökkenőmentes integrálását.

SWAP(qs[2], qs[0]);

Most befejezte a kvantum Fourier qubitszintű műveleteinek írását a Q# műveletbe:

Diagram a három qubites Quantum Fourier Transform kapcsolatcsoportról.

Qubitek felszabadítása

Az utolsó lépés a DumpMachine() művelet utáni állapot megtekintése és a qubitek felszabadítása. A qubitek $\ket{0}$ állapotban voltak, amikor lefoglalta őket, és a ResetAll művelettel alaphelyzetbe kell állítani a kezdeti állapotukat.

Annak megkövetelése, hogy az összes qubitet explicit módon állítsa vissza $\ket{0}$ értékre, az a alapfunkciója Q#, mivel lehetővé teszi, hogy más műveletek pontosan tudják az állapotukat, amikor ugyanazokat a qubiteket (szűkös erőforrást) kezdik használni. Emellett ez biztosítja, hogy a rendszer semmilyen más qubitjéhez nem kapcsolódnak. Ha az alaphelyzetbe állítás nem történik meg egy use foglalási blokk végén, futásidejű hiba jelenhet meg.

Adja hozzá a következő sorokat a fájlhoz Q# :

Message("After:");
DumpMachine();

ResetAll(qs); // deallocate qubits

A teljes QFT-művelet

A Q# program befejeződött. A QFTcircuit.qs fájlnak a következőképpen kell kinéznie:

namespace NamespaceQFT {
    open Microsoft.Quantum.Intrinsic;
    open Microsoft.Quantum.Diagnostics;
    open Microsoft.Quantum.Math;
    open Microsoft.Quantum.Arrays;

    operation Perform3qubitQFT() : Unit {

        use qs = Qubit[3]; // allocate three qubits

        Message("Initial state |000>:");
        DumpMachine();

        //QFT:
        //first qubit:
        H(qs[0]);
        Controlled R1([qs[1]], (PI()/2.0, qs[0]));
        Controlled R1([qs[2]], (PI()/4.0, qs[0]));

        //second qubit:
        H(qs[1]);
        Controlled R1([qs[2]], (PI()/2.0, qs[1]));

        //third qubit:
        H(qs[2]);

        SWAP(qs[2], qs[0]);

        Message("After:");
        DumpMachine();

        ResetAll(qs); // deallocate qubits

    }
}

A QFT-kapcsolatcsoport futtatása

A művelet egyelőre Perform3qubitQFT nem ad vissza értéket – a művelet értéket ad Unit vissza. Később úgy módosítja a műveletet, hogy a mérési eredmények tömbje (Result[]) legyen visszaadva.

Q# önálló program
Jupyter Notebook

Program futtatásakor Q# hozzá kell adnia egy fájlt EntryPoint a Q# fájlhoz. Ez az attribútum azt jelzi a fordítónak, hogy ez a művelet a program belépési pontja. A művelet előtt adja hozzá a következő sort a Q# fájl elejéhez Perform3qubitQFT :
```
@EntryPoint()
operation Perform3qubitQFT() : Unit {
```
A program futtatása előtt a profilt Korlátlan értékre kell állítaniatarget. Válassza a Nézet –> Parancskatalógus lehetőséget, keresse meg a QIR-t, válassza Q#a : Az Azure Quantum QIR-profil target beállítása lehetőséget, majd válassza a : korlátlan lehetőségetQ#.
A program futtatásához válassza a Lejátszás ikon legördülő menü Fájl futtatása Q# elemét a jobb felső sarokban, vagy nyomja le a Ctrl+F5 billentyűkombinációt. A program az alapértelmezett szimulátoron az attribútummal @EntryPoint() megjelölt műveletet vagy függvényt futtatja.
A Message és DumpMachine kimenetek a hibakeresési konzolon jelennek meg.

Megjegyzés

Ha a target profil nincs korlátlan értékre állítva, a program futtatásakor hibaüzenet jelenik meg.

A VS Code-ban válassza a Parancspaletta megtekintése > lehetőséget, majd válassza a Létrehozás: Új Jupyter Notebook lehetőséget.
Az első cellában importálja a csomagot a qsharp Python-kódba:
```
import qsharp
```

Adja hozzá a Q# programot a Perform3qubitQFT művelettel. Ehhez használja a %%qhsarp magic parancsot. Vegye figyelembe, hogy a parancs típusról %%qsharp típusra PythonQ#módosítja a jegyzetfüzet celláját. Másolja a kódot a második cellába.

%%qsharp
open Microsoft.Quantum.Intrinsic;
open Microsoft.Quantum.Diagnostics;
open Microsoft.Quantum.Math;
open Microsoft.Quantum.Arrays;

operation Perform3qubitQFT() : Unit {

    use qs = Qubit[3]; // allocate three qubits

    Message("Initial state |000>:");
    DumpMachine();

    //QFT:
    //first qubit:
    H(qs[0]);
    Controlled R1([qs[1]], (PI()/2.0, qs[0]));
    Controlled R1([qs[2]], (PI()/4.0, qs[0]));

    //second qubit:
    H(qs[1]);
    Controlled R1([qs[2]], (PI()/2.0, qs[1]));

    //third qubit:
    H(qs[2]);

    SWAP(qs[2], qs[0]);

    Message("After:");
    DumpMachine();

    ResetAll(qs); // deallocate qubits

}

Végül futtassa a kódot. Ugyanazt a szimulációt több alkalommal is futtathatja egymástól függetlenül. Minden független szimulációt "lövésnek" nevezünk. Futtassuk például a szimulációt 10-szer.
```
results = qsharp.run("Perform3qubitQFT()", shots=10)
print(results)
```

A QFT-kapcsolatcsoport kimenetének ismertetése

A teljes állapotú szimulátoron DumpMachine() való meghíváskor a kvantumállapot hullámfüggvényének több reprezentációját is biztosítja. A $n$-qubit rendszer lehetséges állapotait $2^n$ számítási alapállapotok jelölhetik, amelyek mindegyike megfelelő összetett együtthatóval (amplitúdóval és fázissal) rendelkezik. A számítási alapállapotok a $n$ hosszúságú összes lehetséges bináris sztringnek felelnek meg, azaz a $\ket$ és $\ket{0}{1}$ qubit-állapotok összes lehetséges kombinációjának, ahol minden bináris számjegy egy adott qubitnek felel meg.

Az első sor megjegyzést ad a megfelelő qubitek azonosítóival jelentős sorrendben. A "legjelentősebb" qubit 2 azt jelenti, hogy a $\ket{i}$ alapállapot-vektor bináris ábrázolásában a qubit 2 állapota a bal oldali számjegynek felel meg. A $\ket{6} = \ket{110}$ például qubiteket2, $\ket{1}$ és 1 qubitet 0 tartalmaz a $\ket{0}$-ban.

A többi sor a $\ket{i}$ alapállapot-vektor cartesian és polar formátumban történő mérésének valószínűségi amplitúdóját írja le. A $\ket{000}$bemeneti állapot első sorának vizsgálata:

|0>: Ez a sor a 0 számítási alap állapotának felel meg (tekintettel arra, hogy a kezdeti állapot a kiosztás után $\ket{000}$ volt, várhatóan ez lesz az egyetlen olyan állapot, amelynek valószínűségi amplitúdója ezen a ponton van).
1.000000 + 0.000000 i: A valószínűségi amplitúdó Cartesian formátumban.
==: a equal jel mindkét egyenértékű reprezentációt elkülöníti.
********************: A magnitúdó grafikus ábrázolása. A szám * arányos az állapotvektor mérésének valószínűségével.
[ 1.000000 ]: A magnitúdó numerikus értéke.
---: Az amplitúdó fázisának grafikus ábrázolása.
[ 0.0000 rad ]: A fázis numerikus értéke (radiánban).

Mind a magnitúdó, mind a fázis grafikus ábrázolással jelenik meg. A magnitúdó ábrázolása egyszerű: egy sávot * jelenít meg, és minél nagyobb a valószínűsége, annál hosszabb lesz a sáv.

A megjelenített kimenet azt mutatja, hogy a programozott műveletek átalakították az állapotot a

$$ \ket{\psi}_{initial} = \ket{000} $$

felhasználóként a(z)

$$ \begin{align} \ket{\psi}_{final} &= \frac{1}{\sqrt{8}} \left( \ket{000} + \ket{001} + \ket{010} + \ket{011} + \ket + \ket + \ket + \ket{100}{101} + \ket{110} + \ket{111} \right) \\ &= \frac{1}{\sqrt{2^n}}\sum_{j=0}^{2^n-1} \ket{j}, \end{align} $$

ez pontosan a három qubites Fourier-transzformáció viselkedése.

Ha kíváncsi arra, hogy más bemeneti állapotok hogyan érintik, javasoljuk, hogy kísérletezzen más qubitműveletek alkalmazásával az átalakítás előtt.

Mérések hozzáadása a QFT-kapcsolatcsoporthoz

A függvényből származó DumpMachine kijelző a művelet eredményeit mutatta, de sajnos a kvantummechanika egyik sarokköve azt állítja, hogy egy valódi kvantumrendszer nem rendelkezhet ilyen DumpMachine függvénnyel. Ehelyett az információkat méréseken keresztül nyerik ki, amelyek általában nem csak a teljes kvantumállapotra vonatkozó információkat adják meg, hanem magát a rendszert is drasztikusan megváltoztathatják.

Számos kvantummérés létezik, de az alábbi példa a legalapvetőbbre összpontosít: az egy qubiten végzett projektív mérésekre. Egy adott alapérték (például $ { \ket{0}, \ket{1} } $ számítási alap) mérésekor a qubit-állapot bármelyik alapállapotra lesz kivetítve, így megsemmisíti a kettő közötti szuperpozíciót.

A QFT-művelet módosítása

A mérések programon belüli Q# implementálásához használja a M műveletet, amely egy típust Result ad vissza.

Először módosítsa a Perform3QubitQFT műveletet úgy, hogy a helyett a mértékegységek tömbét adja vissza. Result[]Unit

operation Perform3QubitQFT() : Result[] {

Tömb definiálása és inicializálása `Result[]`

A qubitek lefoglalása előtt deklaráljon és kösse össze a háromelemű tömböt (minden qubithez egyet Result ):

mutable resultArray = [Zero, size = 3];

A mutable kulcsszó-előkészítés resultArray lehetővé teszi a változó módosítását a kód későbbi részében, például a mérési eredmények hozzáadásakor.

Mérések végrehajtása hurokban `for` , és eredmények hozzáadása a tömbhöz

A QFT-átalakítási műveletek után szúrja be a következő kódot:

for i in IndexRange(qs) {
    set resultArray w/= i <- M(qs[i]);
}

A IndexRange tömbben hívott függvény (például qubitek tömbje, qs) egy tartományt ad vissza a tömb indexei felett. Itt a hurokban használjuk az for egyes qubitek egymás utáni mérésére az M(qs[i]) utasítás használatával. Ezután a rendszer minden mért típust Result (vagy ZeroOne) hozzáad a megfelelő indexpozícióhoz resultArray egy frissítési és újrahozzárendelési utasítással.

Megjegyzés

Ennek az utasításnak a szintaxisa egyedi a értékre Q#, de megfelel a más nyelvekben, például az F# és az R nyelvben látott hasonló változó-hozzárendelésnek resultArray[i] <- M(qs[i]) .

A kulcsszót set mindig a használatával mutablekötött változók újbóli hozzárendelésére használják.

Vissza `resultArray`

A három qubit mérése és a hozzá hozzáadott resultArrayeredmények alapján biztonságosan alaphelyzetbe állíthatja és felszabadíthatja a qubiteket, mint korábban. A mérések visszaadásához szúrja be a következőt:

return resultArray;

A QFT-kapcsolatcsoport futtatása a mérésekkel

Most módosítsa a függvények elhelyezését, DumpMachine hogy a mérések előtti és utáni állapotot adja ki. Az utolsó Q# kódnak így kell kinéznie:

namespace NamespaceQFT {
    open Microsoft.Quantum.Intrinsic;
    open Microsoft.Quantum.Diagnostics;
    open Microsoft.Quantum.Math;
    open Microsoft.Quantum.Arrays;

    operation Perform3QubitQFT() : Result[] {

        mutable resultArray = [Zero, size = 3];

        use qs = Qubit[3];

        //QFT:
        //first qubit:
        H(qs[0]);
        Controlled R1([qs[1]], (PI()/2.0, qs[0]));
        Controlled R1([qs[2]], (PI()/4.0, qs[0]));

        //second qubit:
        H(qs[1]);
        Controlled R1([qs[2]], (PI()/2.0, qs[1]));

        //third qubit:
        H(qs[2]);

        SWAP(qs[2], qs[0]);

        Message("Before measurement: ");
        DumpMachine();

        for i in IndexRange(qs) {
            set resultArray w/= i <- M(qs[i]);
        }

        Message("After measurement: ");
        DumpMachine();

        ResetAll(qs);
        Message("Post-QFT measurement results [qubit0, qubit1, qubit2]: ");
        return resultArray;

    }
}

Tipp

Ne felejtse el menteni a fájlt minden alkalommal, amikor módosítást vezet be a kódban, mielőtt újra futtatja.

Q# önálló program
Jupyter Notebook

Adjon hozzá egy elemet EntryPoint a Perform3qubitQFT művelet előtt:
```
@EntryPoint()
operation Perform3qubitQFT() : Unit {
```
Állítsa a profilt targetKorlátlan értékre. Kattintson a QIR: Base gombra a VS Code ablak alján, és válassza a Korlátlan lehetőséget a legördülő menüben. Ha a target profil nincs korlátlan értékre állítva, a program futtatásakor hibaüzenet jelenik meg.
A program futtatásához válassza a Fájl futtatása Q# lehetőséget a lejátszás ikon legördülő menüjében a jobb felső sarokban, vagy nyomja le a Ctrl+5 billentyűkombinációt. A program az alapértelmezett szimulátoron az attribútummal @EntryPoint() megjelölt műveletet vagy függvényt futtatja.
A Message és DumpMachine kimenetek a hibakeresési konzolon jelennek meg.

A kimenetnek a kimenethez hasonlóan kell kinéznie:

Before measurement: 
# wave function for qubits with ids (least to most significant): 0;1;2
|0>:     0.353553 +  0.000000 i  ==     ***                  [ 0.125000 ]     --- [  0.00000 rad ]
|1>:     0.353553 +  0.000000 i  ==     ***                  [ 0.125000 ]     --- [  0.00000 rad ]
|2>:     0.353553 +  0.000000 i  ==     ***                  [ 0.125000 ]     --- [  0.00000 rad ]
|3>:     0.353553 +  0.000000 i  ==     ***                  [ 0.125000 ]     --- [  0.00000 rad ]
|4>:     0.353553 +  0.000000 i  ==     ***                  [ 0.125000 ]     --- [  0.00000 rad ]
|5>:     0.353553 +  0.000000 i  ==     ***                  [ 0.125000 ]     --- [  0.00000 rad ]
|6>:     0.353553 +  0.000000 i  ==     ***                  [ 0.125000 ]     --- [  0.00000 rad ]
|7>:     0.353553 +  0.000000 i  ==     ***                  [ 0.125000 ]     --- [  0.00000 rad ]
After measurement:
# wave function for qubits with ids (least to most significant): 0;1;2
|0>:     0.000000 +  0.000000 i  ==                          [ 0.000000 ]
|1>:     0.000000 +  0.000000 i  ==                          [ 0.000000 ]
|2>:     0.000000 +  0.000000 i  ==                          [ 0.000000 ]
|3>:     1.000000 +  0.000000 i  ==     ******************** [ 1.000000 ]     --- [  0.00000 rad ]
|4>:     0.000000 +  0.000000 i  ==                          [ 0.000000 ]
|5>:     0.000000 +  0.000000 i  ==                          [ 0.000000 ]
|6>:     0.000000 +  0.000000 i  ==                          [ 0.000000 ]
|7>:     0.000000 +  0.000000 i  ==                          [ 0.000000 ]

Post-QFT measurement results [qubit0, qubit1, qubit2]: 
[One,One,Zero]

Frissítse a cellát a programmal a Q# mérési eredmények visszaadásához. Ehhez másolja a következő kódot a második cellába:

%%qsharp

open Microsoft.Quantum.Intrinsic;
open Microsoft.Quantum.Diagnostics;
open Microsoft.Quantum.Math;
open Microsoft.Quantum.Arrays;

operation Perform3QubitQFT() : Result[] {

    mutable resultArray = [Zero, size = 3];

    use qs = Qubit[3];

    //QFT:
    //first qubit:
    H(qs[0]);
    Controlled R1([qs[1]], (PI()/2.0, qs[0]));
    Controlled R1([qs[2]], (PI()/4.0, qs[0]));

    //second qubit:
    H(qs[1]);
    Controlled R1([qs[2]], (PI()/2.0, qs[1]));

    //third qubit:
    H(qs[2]);

    SWAP(qs[2], qs[0]);

    Message("Before measurement: ");
    DumpMachine();

    for i in IndexRange(qs) {
        set resultArray w/= i <- M(qs[i]);
    }

    Message("After measurement: ");
    DumpMachine();

    ResetAll(qs);
    Message("Post-QFT measurement results [qubit0, qubit1, qubit2]: ");
    return resultArray;

}

Futtassa a kódot.

results = qsharp.run("Perform3QubitQFT()", shots=10)
print(results)

Ez a kimenet néhány különböző dolgot mutat be:

A visszaadott eredmény és az előmérés DumpMachineösszehasonlítása egyértelműen nem szemlélteti a QFT utáni szuperpozíciót az alapállapotok alapján. A mérés csak egy alapállapotot ad vissza, amelynek valószínűségét az adott állapot amplitúdója határozza meg a rendszer hullámfüggvényében.
A mérés DumpMachineutáni állapotból láthatja, hogy a mérés magát az állapotot módosítja , és a kezdeti szuperpozícióból az alapállapotok fölé vetül a mért értéknek megfelelő egyetlen alapállapotra.

Ha ezt a műveletet sokszor megismételi, az eredménystatisztikák elkezdik szemléltetni a QFT utáni állapot ugyanolyan súlyozott szuperpozícióját, amely véletlenszerű eredményt ad minden lövésnél. Amellett azonban, hogy nem hatékony és még mindig nem tökéletes, ez azonban csak az alapállapotok relatív amplitúdóit reprodukálja, nem pedig a közöttük lévő relatív fázisokat. Ez utóbbi nem jelent problémát ebben a példában, de relatív fázisok jelennek meg, ha összetettebb bemenetet ad a QFT-hez, mint a $\ket{000}$.

Q# A műveletek használatával egyszerűsítheti a QFT-kapcsolatcsoportot

Amint azt a bevezetésben említettük, a hatalom nagy része Q#abban rejlik, hogy lehetővé teszi az egyes qubitek kezelésével kapcsolatos aggodalmak absztrakcióját. Ha teljes léptékű, alkalmazható kvantumprogramokat szeretne fejleszteni, attól kell tartania, hogy egy H művelet egy adott forgatás előtt vagy után megy végbe, csak lelassítja.

A Q# névtér Microsoft.Quantum.Canon tartalmazza a ApplyQFT műveletet, amelyet tetszőleges számú qubithez használhat és alkalmazhat.

A ApplyQFT művelet eléréséhez adja hozzá open a Microsoft.Quantum.Canon névtér utasítását a Q# fájl elején:
```
open Microsoft.Quantum.Canon;
```
Cserélje le az első H helyett a SWAP következőt:
```
ApplyQFT(qs);
```
Futtassa újra a Q# programot, és figyelje meg, hogy a kimenet ugyanaz, mint korábban.
A műveletek használatának Q# valódi előnyeinek megtekintéséhez módosítsa a qubitek számát a következőtől 3eltérőre:

mutable resultArray = [Zero, size = 4];

use qs = Qubit[4];
//...

Így bármilyen qubithez alkalmazhatja a megfelelő QFT-t anélkül, hogy az egyes qubiteken az új H műveletek és rotációk miatt kellene aggódnia.

Következő lépések

Ismerkedjen meg más Q# oktatóanyagokkal:

A kvantum véletlenszerű számgenerátor bemutatja, hogyan írhat olyan Q# programot, amely véletlenszerű számokat hoz létre qubitből szuperpozícióban.
A Grover keresési algoritmusa bemutatja, hogyan írhat olyan Q# programot, amely a Grover keresési algoritmusát használja.
A kvantum-összefonódás bemutatja, hogyan írhat olyan Q# programot, amely a qubiteket manipulálja és méri, és bemutatja a szuperpozíció és az összefonódás hatásait.
A Quantum Katas öngyors oktatóanyagok és programozási gyakorlatok, amelyek célja a kvantum-számítástechnika és Q# a programozás elemeinek egyidejű tanítása.

Oktatóanyag: A Quantum Fourier-átalakítás implementálása Q#

Előfeltételek

új Q# fájl Létrehozás

QFT-kapcsolatcsoport írása Q#

Más műveletek eléréséhez szükséges Q# névterek

Műveletek definiálása argumentumokkal és visszatérésekkel

Qubitek lefoglalása

Egy qubites és szabályozott műveletek alkalmazása

SWAP művelet alkalmazása

Qubitek felszabadítása

A teljes QFT-művelet

A QFT-kapcsolatcsoport futtatása

A QFT-kapcsolatcsoport kimenetének ismertetése

Mérések hozzáadása a QFT-kapcsolatcsoporthoz

A QFT-művelet módosítása

Tömb definiálása és inicializálása `Result[]`

Mérések végrehajtása hurokban `for` , és eredmények hozzáadása a tömbhöz

Vissza `resultArray`

A QFT-kapcsolatcsoport futtatása a mérésekkel

Q# A műveletek használatával egyszerűsítheti a QFT-kapcsolatcsoportot

Következő lépések

Visszajelzés

Visszajelzés

További források

Oktatóanyag: A Quantum Fourier-átalakítás implementálása Q#

Előfeltételek

új Q# fájl Létrehozás

QFT-kapcsolatcsoport írása Q#

Más műveletek eléréséhez szükséges Q# névterek

Műveletek definiálása argumentumokkal és visszatérésekkel

Qubitek lefoglalása

Egy qubites és szabályozott műveletek alkalmazása

SWAP művelet alkalmazása

Qubitek felszabadítása

A teljes QFT-művelet

A QFT-kapcsolatcsoport futtatása

A QFT-kapcsolatcsoport kimenetének ismertetése

Mérések hozzáadása a QFT-kapcsolatcsoporthoz

A QFT-művelet módosítása

Tömb definiálása és inicializálása Result[]

Mérések végrehajtása hurokban for , és eredmények hozzáadása a tömbhöz

Vissza resultArray

A QFT-kapcsolatcsoport futtatása a mérésekkel

Q# A műveletek használatával egyszerűsítheti a QFT-kapcsolatcsoportot

Következő lépések

Visszajelzés

Visszajelzés

További források

Tömb definiálása és inicializálása `Result[]`

Mérések végrehajtása hurokban `for` , és eredmények hozzáadása a tömbhöz

Vissza `resultArray`