Zelfstudie: De Quantum Fourier-transformatie implementeren in Q#

Artikel
01/13/2024

Notitie

Quantum Development Kit Microsoft (klassieke QDK) wordt na 30 juni 2024 niet meer ondersteund. Als u een bestaande QDK-ontwikkelaar bent, raden we u aan over te stappen op de nieuwe Azure Quantum Development Kit (Moderne QDK) om door te gaan met het ontwikkelen van kwantumoplossingen. Zie Uw code migreren Q# naar de moderne QDK voor meer informatie.

In deze zelfstudie leert u hoe u een eenvoudig kwantumprogramma schrijft en simuleert dat werkt op afzonderlijke qubits.

Hoewel Q# het voornamelijk is gemaakt als een programmeertaal op hoog niveau voor grootschalige kwantumprogramma's, kan het ook worden gebruikt om het lagere niveau van kwantumprogrammering te verkennen, dat wil gezegd, rechtstreeks gericht op specifieke qubits. In deze zelfstudie wordt in het bijzonder de Quantum Fourier Transform (QFT) nader bekeken, een subroutine die een integraal onderdeel is van veel grotere kwantumalgoritmen.

In deze zelfstudie leert u het volgende:

Definieer kwantumbewerkingen in Q#.
Het Quantum Fourier-transformatiecircuit schrijven
Een kwantumbewerking simuleren van qubittoewijzing tot meetuitvoer.
Bekijk hoe de gesimuleerde golffunctie van het kwantumsysteem zich tijdens de bewerking ontwikkelt.

Notitie

Deze weergave op een lager niveau van kwantuminformatieverwerking wordt vaak beschreven in termen van kwantumcircuits, die de sequentiële toepassing van poorten of bewerkingen op specifieke qubits van een systeem vertegenwoordigen. De bewerkingen met één en meerdere qubits die u opeenvolgend toepast, kunnen dus gemakkelijk worden weergegeven in circuitdiagrammen. De volledige kwantum-Fourier-transformatie met drie qubits die in deze zelfstudie wordt gebruikt, heeft bijvoorbeeld de volgende weergave als circuit: Diagram van een Quantum Fourier-transformatiecircuit.

Tip

Als u uw kwantumcomputingtraject wilt versnellen, raadpleegt u Code met Azure Quantum, een unieke functie van de Azure Quantum-website. Hier kunt u ingebouwde Q# voorbeelden of uw eigen Q# programma's uitvoeren, nieuwe Q# code genereren op basis van uw prompts, uw code openen en uitvoeren in VS Code voor het web met één klik en Copilot vragen stellen over kwantumcomputing.

Vereisten

De nieuwste versie van Visual Studio Code of open VS Code op het web.
De nieuwste versie van de Azure-extensie Quantum Development Kit . Zie Installing the Modern QDK on VS Code (De moderne QDK installeren op VS Code) voor installatiedetails.
Als u Jupyter Notebooks wilt gebruiken, moet u ook Python- en Jupyter-extensies en het nieuwste qsharp Python-pakket installeren. Open hiervoor een terminal en voer de volgende opdracht uit:
```
$ pip install --upgrade  qsharp
```

Een nieuw Q# bestand Creatie

Selecteer in VS Code Bestand > Nieuw tekstbestand
Sla het bestand op als QFTcircuit.qs. Dit bestand bevat de Q# code voor uw programma.
Open QFTcircuit.qs.

Een QFT-circuit schrijven in Q#

Het eerste deel van deze zelfstudie bestaat uit het definiëren van de Q# bewerking Perform3qubitQFT, waarmee de kwantum-Fourier-transformatie wordt uitgevoerd op drie qubits. De DumpMachine functie wordt gebruikt om te observeren hoe de gesimuleerde golffunctie van het systeem met drie qubits zich ontwikkelt tijdens de bewerking. In het tweede deel van de zelfstudie voegt u meetfunctionaliteit toe en vergelijkt u de statussen vóór en na de meting van de qubits.

U bouwt de bewerking stap voor stap. Kopieer en plak de code in de volgende secties in het bestand QFTcircuit.qs .

U kunt de volledige Q# code voor deze sectie als referentie bekijken.

Naamruimten voor toegang tot andere Q# bewerkingen

Definieer in het Q# bestand de naamruimte NamespaceQFT, waartoe de compiler toegang heeft. Als u wilt dat deze bewerking gebruikmaakt van bestaande Q# bewerkingen, opent u de relevante Microsoft.Quantum.* naamruimten.

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

    // operations go here
}

Bewerkingen definiëren met argumenten en retournaties

Definieer vervolgens de Perform3qubitQFT bewerking:

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

Voorlopig neemt de bewerking geen argumenten en retourneert een Unit -object, dat vergelijkbaar is met het retourneren void in C# of een lege tuple, Tuple[()], in Python. Later wijzigt u de bewerking om een matrix met meetresultaten te retourneren.

Qubits toewijzen

Wijs binnen de Q# bewerking een register van drie qubits toe met het use trefwoord. Met useworden de qubits automatisch toegewezen in de status $\ket{0}$.

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

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

Net als bij echte kwantumberekeningen kunt Q# u niet rechtstreeks toegang krijgen tot qubitstatussen. Met de DumpMachine bewerking wordt echter de huidige status van de target machine afgedrukt, zodat deze waardevol inzicht kan bieden voor foutopsporing en leren wanneer deze wordt gebruikt in combinatie met de volledige statussimulator.

Eén qubit en beheerde bewerkingen toepassen

Vervolgens past u de bewerkingen toe waaruit de Perform3qubitQFT bewerking zelf bestaat. Q# bevat deze en vele andere kwantumbewerkingen al in de Microsoft.Quantum.Intrinsic naamruimte.

De eerste bewerking die wordt toegepast, is de H bewerking (Hadamard) op de eerste qubit:

Diagram met een circuit voor drie qubit QFT via de eerste Hadamard.

Als u een bewerking wilt toepassen op een specifieke qubit vanuit een register (bijvoorbeeld één Qubit uit een matrix Qubit[]), gebruikt u de standaardindexnotatie. Het toepassen van de H bewerking op de eerste qubit van het register qs heeft dus de volgende vorm:

H(qs[0]);

Naast het toepassen van de H bewerking op afzonderlijke qubits, bestaat het QFT-circuit voornamelijk uit gecontroleerde R1 rotaties. Bij een R1(θ, <qubit>) bewerking blijft het onderdeel $\ket{0}$ van de qubit over het algemeen ongewijzigd tijdens het toepassen van een rotatie van $e^{i\theta}$ op het onderdeel $\ket{1}$.

Q# maakt het eenvoudig om de uitvoering van een bewerking op één of meerdere controle-qubits te bepalen. Over het algemeen wordt de aanroep voorafgegaan door Controlleden worden de bewerkingsargumenten als volgt gewijzigd:

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

Houd er rekening mee dat het argument controle-qubit een matrix moet zijn, zelfs als het voor één qubit is.

De beheerde bewerkingen in de QFT zijn de R1 bewerkingen die werken op de eerste qubit (en beheerd door de tweede en derde qubits):

Diagram met een circuit voor drie qubits Quantum Fourier-transformatie via de eerste qubit.

Roep in het Q# bestand deze bewerkingen aan met de volgende instructies:

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

De PI() functie wordt gebruikt om de rotaties te definiëren in termen van pi-radialen.

SWAP-bewerking toepassen

Na het toepassen van de relevante H bewerkingen en gecontroleerde rotaties op de tweede en derde qubits, ziet het circuit er als volgt uit:

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

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

Ten slotte past u een SWAP bewerking toe op de eerste en derde qubits om het circuit te voltooien. Dit is nodig omdat de aard van de kwantum-Fourier-transformatie de qubits in omgekeerde volgorde uitvoert, zodat de wissels naadloze integratie van de subroutine in grotere algoritmen mogelijk maken.

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

Nu bent u klaar met het schrijven van de bewerkingen op qubitniveau van de kwantum-Fourier-transformatie naar uw Q# bewerking:

Diagram met een circuit voor drie qubits Quantum Fourier Transform.

Toewijzing van qubits ongedaan maken

De laatste stap bestaat uit het opnieuw aanroepen DumpMachine() van de status na de bewerking en het ongedaan maken van de toewijzing van de qubits. De qubits hadden de status $\ket{0}$ toen u ze toedeelde en moeten worden teruggezet naar hun oorspronkelijke status met behulp van de ResetAll bewerking.

Vereisen dat alle qubits expliciet opnieuw worden ingesteld op $\ket{0}$ is een basisfunctie van Q#, omdat andere bewerkingen hun status precies kunnen kennen wanneer ze dezelfde qubits gaan gebruiken (een schaarse resource). Bovendien zorgt dit ervoor dat ze niet verstrengeld zijn met andere qubits in het systeem. Als het opnieuw instellen niet wordt uitgevoerd aan het einde van een use toewijzingsblok, kan er een runtimefout optreden.

Voeg de volgende regels toe aan het Q# bestand:

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

ResetAll(qs); // deallocate qubits

De volledige QFT-bewerking

Het Q# programma is voltooid. Uw QFTcircuit.qs-bestand moet er nu als volgt uitzien:

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

    }
}

Het QFT-circuit uitvoeren

Op dit moment retourneert de Perform3qubitQFT bewerking geen waarde. De bewerking retourneert Unit een waarde. Later wijzigt u de bewerking om een matrix met meetresultaten (Result[]) te retourneren.

Q# zelfstandig programma
Jupyter Notebook

Wanneer u een Q# programma uitvoert, moet u een EntryPoint toevoegen aan het Q# bestand. Dit kenmerk vertelt de compiler dat deze bewerking het toegangspunt voor het programma is. Voeg vóór de bewerking de volgende regel toe aan het begin van het Q#Perform3qubitQFT bestand :
```
@EntryPoint()
operation Perform3qubitQFT() : Unit {
```
Voordat u het programma uitvoert, moet u het target profiel instellen op Onbeperkt. Selecteer Weergave -> Opdrachtpalet, zoek naar QIR, selecteer Q#: Stel het Azure Quantum QIR-profiel targetin en selecteer Q#vervolgens : onbeperkt.
Als u het programma wilt uitvoeren, selecteert u Bestand uitvoeren Q# in de vervolgkeuzelijst met het afspeelpictogram in de rechterbovenhoek of drukt u op Ctrl+F5. Het programma voert de bewerking of functie uit die is gemarkeerd met het @EntryPoint() kenmerk op de standaardsimulator.
De Message uitvoer en DumpMachine worden weergegeven in de console voor foutopsporing.

Notitie

Als het target profiel niet is ingesteld op Onbeperkt, krijgt u een foutmelding wanneer u het programma uitvoert.

Selecteer in VS Code opdrachtpalet weergeven > en selecteer Creatie: Nieuwe Jupyter Notebook.
Importeer in de eerste cel het qsharp pakket in uw Python-code:
```
import qsharp
```

Voeg het Q# programma toe met de Perform3qubitQFT bewerking. Hiervoor gebruikt u de %%qhsarp magic-opdracht. Houd er rekening mee dat met de %%qsharp opdracht de notebookcel wordt gewijzigd van type Python in type Q#. Kopieer deze code naar de tweede cel.

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

}

Voer ten slotte de code uit. U kunt dezelfde simulatie een aantal keer onafhankelijk uitvoeren. Elke onafhankelijke simulatie wordt een 'shot' genoemd. Laten we bijvoorbeeld de simulatie tien keer uitvoeren.
```
results = qsharp.run("Perform3qubitQFT()", shots=10)
print(results)
```

Inzicht in de uitvoer van het QFT-circuit

Wanneer de volledige-statussimulator wordt aangeroepen, DumpMachine() worden deze meerdere weergaven van de golffunctie van de kwantumstatus weergegeven. De mogelijke toestanden van een $n$-qubitsysteem kunnen worden vertegenwoordigd door $2^n$ rekenkundige basistoestanden, elk met een overeenkomstige complexe coëfficiënt (een amplitude en een fase). De rekenkundige basisstatussen komen overeen met alle mogelijke binaire tekenreeksen met lengte $n$, dat wil weten alle mogelijke combinaties van qubitstatussen $\ket{0}$ en $\ket{1}$, waarbij elk binair cijfer overeenkomt met een afzonderlijke qubit.

De eerste rij bevat een opmerking met de id's van de bijbehorende qubits in hun significante volgorde. Qubit 2 is de 'meest significante' betekent dat in de binaire weergave van de basisstatusvector $\ket{i}$, de toestand van qubit 2 overeenkomt met het meest linkse cijfer. $\ket{6} = \ket{110}$ omvat bijvoorbeeld qubits 2 en 1 zowel in $\ket{1}$ als in 0 $\ket{0}$.

De rest van de rijen beschrijven de waarschijnlijkheidsamplitude van het meten van de basistoestandsvector $\ket{i}$ in zowel cartesische als polaire indeling. De eerste rij wordt gecontroleerd op de invoerstatus $\ket{000}$:

|0>: Deze rij komt overeen met de 0 rekenkundige basisstatus (aangezien de aanvankelijke status na toewijzing $\ket{000}$ was, is dit naar verwachting de enige toestand met waarschijnlijkheidsamplitude op dit punt).
1.000000 + 0.000000 i: De waarschijnlijkheidsamplitude in Cartesische notatie.
==: het equal teken scheidt beide equivalente representaties.
********************: Een grafische weergave van de grootte. Het getal van * is evenredig aan de waarschijnlijkheid van het meten van deze toestandsvector.
[ 1.000000 ]: De numerieke waarde van de magnitude.
---: Een grafische weergave van de amplitudefase.
[ 0.0000 rad ]: De numerieke waarde van de fase (in radialen).

Zowel de grootte als de fase worden weergegeven met een grafische weergave. De grootteweergave is eenvoudig: deze toont een staaf van * en hoe hoger de kans, hoe langer de balk zal zijn.

De weergegeven uitvoer illustreert dat de geprogrammeerde bewerkingen de status van

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

tot

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

dit is precies het gedrag van de fouriertransformatie met drie qubits.

Als u wilt weten hoe andere invoerstatussen worden beïnvloed, wordt u aangeraden om vóór de transformatie te experimenteren met het toepassen van andere qubitbewerkingen.

Metingen toevoegen aan het QFT-circuit

De weergave van de DumpMachine functie toont de resultaten van de bewerking, maar helaas stelt een hoeksteen van de kwantummechanica dat een echt kwantumsysteem een dergelijke DumpMachine functie niet kan hebben. In plaats daarvan wordt de informatie geëxtraheerd via metingen, die over het algemeen niet alleen geen informatie geven over de volledige kwantumtoestand, maar ook het systeem zelf drastisch kunnen veranderen.

Er zijn veel soorten kwantummetingen, maar het voorbeeld hier is gericht op de meest elementaire: projectieve metingen op enkele qubits. Bij metingen in een bepaalde basis (bijvoorbeeld de rekenkundige basis $ { \ket{0}, \ket{1} } $), wordt de qubitstatus geprojecteerd op de basistoestand die is gemeten, waardoor elke superpositie tussen de twee wordt vernietigd.

De QFT-bewerking wijzigen

Als u metingen binnen een Q# programma wilt implementeren, gebruikt u de M bewerking, die een Result type retourneert.

Wijzig eerst de Perform3QubitQFT bewerking om een matrix met meetresultaten te retourneren, Result[], in plaats van Unit.

operation Perform3QubitQFT() : Result[] {

Matrix definiëren en initialiseren `Result[]`

Voordat u qubits toedeelt, declareert en bindt u een matrix met drie elementen (één Result voor elke qubit):

mutable resultArray = [Zero, size = 3];

Met mutable de prefacing resultArray voor trefwoorden kan de variabele later in de code worden gewijzigd, bijvoorbeeld wanneer u de meetresultaten toevoegt.

Metingen uitvoeren in een `for` lus en resultaten toevoegen aan matrix

Voeg na de QFT-transformatiebewerkingen de volgende code in:

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

De IndexRange functie die wordt aangeroepen voor een matrix (bijvoorbeeld de matrix van qubits, qs) retourneert een bereik over de indexen van de matrix. Hier wordt het in de for lus gebruikt om elke qubit sequentieel te meten met behulp van de M(qs[i]) instructie. Elk gemeten Result type (of Zero ) Onewordt vervolgens toegevoegd aan de bijbehorende indexpositie in resultArray met een instructie bijwerken en opnieuw toewijzen.

Notitie

De syntaxis van deze instructie is uniek Q#voor , maar komt overeen met de vergelijkbare variabele opnieuw toewijzen resultArray[i] <- M(qs[i]) in andere talen, zoals F# en R.

Het trefwoord set wordt altijd gebruikt voor het opnieuw toewijzen van afhankelijke variabelen met behulp van mutable.

Terug `resultArray`

Nu alle drie de qubits zijn gemeten en de resultaten zijn toegevoegd aan resultArray, kunt u de qubits opnieuw instellen en de toewijzing ervan ongedaan maken zoals voorheen. Als u de metingen wilt retourneren, voegt u het volgende in:

return resultArray;

Het QFT-circuit uitvoeren met de metingen

Wijzig nu de plaatsing van de DumpMachine functies om de status voor en na de metingen uit te voeren. De uiteindelijke Q# code moet er als volgt uitzien:

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;

    }
}

Tip

Vergeet niet om het bestand op te slaan telkens wanneer u een wijziging in de code aanbrengt voordat u het opnieuw uitvoert.

Q# zelfstandig programma
Jupyter Notebook

Voeg een EntryPoint toe vóór de Perform3qubitQFT bewerking :
```
@EntryPoint()
operation Perform3qubitQFT() : Unit {
```
Stel het target profiel in op Onbeperkt. Klik op de knop QIR: Basis onderaan het VS Code-venster en selecteer Onbeperkt in de vervolgkeuzelijst. Als het target profiel niet is ingesteld op Onbeperkt, krijgt u een foutmelding wanneer u het programma uitvoert.
Als u het programma wilt uitvoeren, selecteert u Bestand uitvoeren Q# in de vervolgkeuzelijst met afspeelpictogram in de rechterbovenhoek of drukt u op Ctrl+5. Het programma voert de bewerking of functie uit die is gemarkeerd met het @EntryPoint() kenmerk in de standaardsimulator.
De Message uitvoer en DumpMachine worden weergegeven in de console voor foutopsporing.

De uitvoer moet er ongeveer uitzien als de uitvoer:

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]

Werk de cel bij met het Q# programma om de meetresultaten te retourneren. Hiervoor kopieert u de volgende code naar de tweede cel:

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

}

Voer de code uit.

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

Deze uitvoer illustreert een aantal verschillende dingen:

Als u het geretourneerde resultaat vergelijkt met de voormeting DumpMachine, wordt duidelijk de post-QFT-superpositie over basisstatussen niet geïllustreerd. Een meting retourneert slechts één basistoestand, met een waarschijnlijkheid die wordt bepaald door de amplitude van die toestand in de golffunctie van het systeem.
Van de post-meting DumpMachineziet u dat de meting zelf verandert , waarbij deze wordt geprojecteerd van de initiële superpositie over basistoestanden naar de enkele basisstatus die overeenkomt met de gemeten waarde.

Als u deze bewerking vaak herhaalt, ziet u dat de resultaatstatistieken de even gewogen superpositie van de post-QFT-status illustreren die aanleiding geeft tot een willekeurig resultaat bij elke opname. Echter, naast inefficiënt en nog steeds onvolmaakt, zou dit niettemin alleen de relatieve amplitudes van de basistoestanden reproduceren, niet de relatieve fasen ertussen. Dit laatste is geen probleem in dit voorbeeld, maar u ziet relatieve fasen verschijnen als u een complexere invoer voor de QFT krijgt dan $\ket{000}$.

Gebruik de Q# bewerkingen om het QFT-circuit te vereenvoudigen

Zoals vermeld in de inleiding, rust veel van Q#'s macht in het feit dat het u in staat stelt om de zorgen van het omgaan met individuele qubits te abstraheren. Als u op volledige schaal toepasbare kwantumprogramma's wilt ontwikkelen, hoeft u zich alleen maar zorgen te maken over de vraag of een H bewerking vóór of na een bepaalde rotatie gaat.

De Q# naamruimte Microsoft.Quantum.Canon bevat de ApplyQFT bewerking, die u kunt gebruiken en toepassen op een willekeurig aantal qubits.

Voor toegang tot de ApplyQFT bewerking voegt u open de instructie toe voor de Microsoft.Quantum.Canon naamruimte aan het begin van het Q# bestand:
```
open Microsoft.Quantum.Canon;
```
Vervang alles van de eerste H tot de SWAP vervangen door:
```
ApplyQFT(qs);
```
Voer het Q# programma opnieuw uit en u ziet dat de uitvoer hetzelfde is als voorheen.
Als u het echte voordeel van het gebruik Q# van bewerkingen wilt zien, wijzigt u het aantal qubits in iets anders dan 3:

mutable resultArray = [Zero, size = 4];

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

U kunt dus de juiste QFT toepassen op een bepaald aantal qubits, zonder dat u zich zorgen hoeft te maken over de rommel van nieuwe H bewerkingen en rotaties op elke qubit.

Volgende stappen

Q# Andere zelfstudies verkennen:

Kwantumgenerator voor willekeurige getallen laat zien hoe u een Q# programma schrijft dat willekeurige getallen genereert uit qubits in superpositie.
Het zoekalgoritmen van Grover laten zien hoe u een Q# programma schrijft dat gebruikmaakt van het zoekalgoritmen van Grover.
Kwantumverstrengeling laat zien hoe u een Q# programma schrijft dat qubits manipuleert en meet en de effecten van superpositie en verstrengeling demonstreert.
De Quantum Katas zijn zelfstudies in eigen tempo en programmeeroefeningen die gericht zijn op het tegelijkertijd aanleren van de elementen van kwantumcomputing en Q# programmeren.

Zelfstudie: De Quantum Fourier-transformatie implementeren in Q#

Vereisten

Een nieuw Q# bestand Creatie

Een QFT-circuit schrijven in Q#

Naamruimten voor toegang tot andere Q# bewerkingen

Bewerkingen definiëren met argumenten en retournaties

Qubits toewijzen

Eén qubit en beheerde bewerkingen toepassen

SWAP-bewerking toepassen

Toewijzing van qubits ongedaan maken

De volledige QFT-bewerking

Het QFT-circuit uitvoeren

Inzicht in de uitvoer van het QFT-circuit

Metingen toevoegen aan het QFT-circuit

De QFT-bewerking wijzigen

Matrix definiëren en initialiseren `Result[]`

Metingen uitvoeren in een `for` lus en resultaten toevoegen aan matrix

Terug `resultArray`

Het QFT-circuit uitvoeren met de metingen

Gebruik de Q# bewerkingen om het QFT-circuit te vereenvoudigen

Volgende stappen

Feedback

Feedback

Aanvullende resources

Zelfstudie: De Quantum Fourier-transformatie implementeren in Q#

Vereisten

Een nieuw Q# bestand Creatie

Een QFT-circuit schrijven in Q#

Naamruimten voor toegang tot andere Q# bewerkingen

Bewerkingen definiëren met argumenten en retournaties

Qubits toewijzen

Eén qubit en beheerde bewerkingen toepassen

SWAP-bewerking toepassen

Toewijzing van qubits ongedaan maken

De volledige QFT-bewerking

Het QFT-circuit uitvoeren

Inzicht in de uitvoer van het QFT-circuit

Metingen toevoegen aan het QFT-circuit

De QFT-bewerking wijzigen

Matrix definiëren en initialiseren Result[]

Metingen uitvoeren in een for lus en resultaten toevoegen aan matrix

Terug resultArray

Het QFT-circuit uitvoeren met de metingen

Gebruik de Q# bewerkingen om het QFT-circuit te vereenvoudigen

Volgende stappen

Feedback

Feedback

Aanvullende resources

Matrix definiëren en initialiseren `Result[]`

Metingen uitvoeren in een `for` lus en resultaten toevoegen aan matrix

Terug `resultArray`