Oefening: verschillende superpositiestatussen maken met Q#

12 minuten

In de vorige lessen hebt u geleerd over superpositie en Dirac-notatie. Dat is genoeg theorie voor nu! Laten we de superpositie in Q# verkennen door wat code te schrijven.

In deze les maakt u kwantumsuperpositie en duikt u in kansen met Q# met behulp van de DumpMachine functie. De DumpMachine functie dumpt informatie over de huidige status van het kwantumsysteem op het punt waar het wordt aangeroepen.

Een nieuw Q#-bestand maken

Open Visual Studio Code.
Selecteer in Visual Studio Code Bestand > nieuw tekstbestand en sla het bestand op als Main.qs.
Selecteer Weergave -> Opdrachtpalet en typ Q#: Stel het Azure Quantum QIR-doelprofiel in. Druk op Enter.
Selecteer Q#: Onbeperkt.

Aan de slag met superpositie

Laten we beginnen met een eenvoudig programma dat een willekeurige bit genereert met behulp van een qubit in superpositie. U gebruikt de DumpMachine functie om de status van de qubit op verschillende punten in het programma te zien.

Voeg de volgende code toe aan het bestand Main.qs :

import Microsoft.Quantum.Diagnostics.*;

operation Main() : Result {
    use q = Qubit();
    Message("Initialized qubit:");
    DumpMachine(); // First dump
    Message(" ");
    H(q);
    Message("Qubit after applying H:");
    DumpMachine(); // Second dump
    Message(" ");
    let randomBit = M(q);
    Message("Qubit after the measurement:");
    DumpMachine(); // Third dump
    Message(" ");
    Reset(q);
    Message("Qubit after resetting:");
    DumpMachine(); // Fourth dump
    Message(" ");
    return randomBit;
}

Hier roept u DumpMachine vier keer aan:

Nadat de qubit is toegewezen.
Nadat u de qubit in superpositie hebt geplaatst.
Nadat u de status van de qubit hebt gemeten.
Nadat u de qubit opnieuw hebt ingesteld.

U splitst de bewerking MResetZ in twee bewerkingen: M en Reset. U doet dit omdat u de status na de meting wilt inspecteren.

Als u uw programma wilt uitvoeren op de ingebouwde simulator, klikt u op Uitvoeren boven de bewerking of drukt u op Main. Uw uitvoer wordt weergegeven in de console voor foutopsporing.
De functie DumpMachine maakt een tabel met de informatie die de status van het qubitregister beschrijft. Concreet geeft het de waarschijnlijkheidsamplitude, de waarschijnlijkheid en de fase in radialen voor elke basistoestand.
Aan het eind van het programma krijgt u een resultaat van Zero of One. Laten we eens kijken naar elke stap.
1. Geïnitialiseerde qubit: elke qubit die met de use instructie wordt toegewezen, begint in de status $|0\rangle$. DumpMachine produceert dus de informatie die overeenkomt met een enkelvoudig qubitregister met de status $|0\rangle$.
```
Initialized qubit:

DumpMachine:

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
   |0⟩ |  1.0000+0.0000𝑖 |   100.0000% |   0.0000
```
2. Qubit na het toepassen van H: Na het toepassen Hbereiden we de qubit voor in de superpositiestatus $|\psi\rangle=\frac1{\sqrt2} |0\rangle + \frac1{\sqrt2} |1\rangle$.
```
Qubit after applying H:

DumpMachine:

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
   |0⟩ |  0.7071+0.0000𝑖 |    50.0000% |   0.0000
   |1⟩ |  0.7071+0.0000𝑖 |    50.0000% |   0.0000
```
3. Qubit na de meting: Nadat we het resultaat hebben gemeten en opgeslagen, wat een Zero of One. Als de resulterende status bijvoorbeeld is, wordt Onede status van de registers samengevouwen tot $|1\rangle$ en bevindt deze zich niet meer in superpositie.
```
Qubit after the measurement:

DumpMachine:

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
   |1⟩ |  1.0000+0.0000𝑖 |   100.0000% |   0.0000
```
4. Qubit na het opnieuw instellen: met de bewerking Reset wordt de qubit opnieuw ingesteld op de status $|0\rangle$. Onthoud dat u voor elke Q#-bewerking altijd de qubits die u gebruikt in de status $|0\rangle$ moet laten, andere bewerkingen deze kunnen gebruiken.
```
Qubit after resetting:

DumpMachine:

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
   |0⟩ |  1.0000+0.0000𝑖 |   100.0000% |   0.0000
```
Notitie

Uw uitvoer kan verschillen omdat de generator voor willekeurige getallen probabilistisch is. De waarschijnlijkheden van de resultaten zijn niet deterministisch.

Andere typen superpositiestatussen verkennen

Nu u weet hoe u de status van een register moet inspecteren, kunt u meer bewerkingen zien die de status van uw qubits wijzigen en deze in een superpositie plaatsen.

De huidige randomgetalgenerator produceert Zero of One met een waarschijnlijkheid van 50%. Laten we eens kijken naar een tweede voorbeeld waarmee random getallen met een andere waarschijnlijkheid worden gegenereerd.

Asymmetrische random-bitgenerator

Stel dat u een willekeurige bitgenerator wilt maken die scheef is, dat wil zeggen dat de waarschijnlijkheid van het ophalen Zero verschilt van de waarschijnlijkheid van het ophalen One.

U wilt bijvoorbeeld het resultaat Zero met waarschijnlijkheid $P$ en het resultaat One met waarschijnlijkheid $1-P$. Hier volgt een geldige qubitstatus die een dergelijke willekeurige bitgenerator produceert:

$$|\psi\rangle=\sqrt{P}|0\rangle+\sqrt{1-P}|1\rangle$$

Hier zijn $\alpha=\sqrt{P}$ en $\beta=\sqrt{1-P}$ respectievelijk de amplitudes van de basisstatussen $|0\rangle$ en $|1\rangle$.

Deze status kan worden verkregen door de operator sequentieel toe te passen $R_y(2\arccos\sqrt{P})$ op een qubit in de toestand $|0\rangle.$ U kunt dit resultaat in Q# bereiken met behulp van de bewerking Ry in de standaardbibliotheek.

Tip

Raadpleeg de zelfstudie Single Qubit Gates in Quantum Katas voor meer informatie over de wiskunde achter bewerkingen met één qubit.

Wijzig Main.qs zoals in het volgende voorbeeld en sla het bestand op. In dit voorbeeld wordt $\alpha$ gekozen als ongeveer $\frac13$.

import Microsoft.Quantum.Diagnostics.*;
import Microsoft.Quantum.Math.*;

operation Main() : Result {
    use q = Qubit();
    let P = 0.333333; // P is 1/3
    Ry(2.0 * ArcCos(Sqrt(P)), q);
    Message("The qubit is in the desired state.");
    Message("");
    DumpMachine(); // Dump the state of the qubit 
    Message("");
    Message("Your skewed random bit is:");
    let skewedrandomBit = M(q);
    Reset(q);
    return skewedrandomBit;
}

Als u uw programma wilt uitvoeren op de ingebouwde simulator, klikt u op Uitvoeren boven de bewerking of drukt u op Main. Uw uitvoer wordt weergegeven in de console voor foutopsporing.
U kunt zien hoe DumpMachine de verwachte status weergeeft nadat u de bewerkingen hebt toegepast en de bijbehorende waarschijnlijkheden weergeeft. U ziet dat de kans op het verkrijgen Zero ongeveer 33,33% is en dat de kans op het verkrijgen One ongeveer 66,67% is. De random-bitgenerator is dus scheef.
```
The qubit is in the desired state.

DumpMachine:

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
   |0⟩ |  0.5773+0.0000𝑖 |    33.3333% |   0.0000
   |1⟩ |  0.8165+0.0000𝑖 |    66.6667% |   0.0000


Your skewed random bit is:
Result: "One"
```
Notitie

De uitvoer kan verschillen omdat de generator voor willekeurige getallen probabilistisch is. De waarschijnlijkheden van de resultaten zijn niet deterministisch.

Superpositie van meerdere qubits

We gaan nu de superposities verkennen van een register dat vele qubits bevat. Als een register bijvoorbeeld uit drie qubits bestaat, hebt u acht basisstatussen:

U kunt de status van een willekeurige status met drie qubits dus als volgt uitdrukken:

Hier zijn $\alpha_i$ complexe getallen die voldoen aan $\sum|\alpha_i|^2=1$.

U kunt bijvoorbeeld qubits in een uniforme superpositie plaatsen door deze toe te passen op H elke qubit. U kunt deze uniforme superpositie gebruiken om een andere versie van de kwantum-randomgetalgenerator te maken waarmee 3-bits getallen worden gegenereerd door drie qubits in superpositie te meten in plaats van één qubit drie keer te meten.

Basis	Aantal
$\ket{000}$	0
$\ket{001}$	1
$\ket{010}$	2
$\ket{011}$	3
$\ket{100}$	4
$\ket{101}$	5
$\ket{110}$	6
$\ket{111}$	7

Wijzig Main.qs zoals in het volgende voorbeeld en sla het bestand op.
```
import Microsoft.Quantum.Diagnostics.*;
import Microsoft.Quantum.Math.*;
import Microsoft.Quantum.Convert.*;
import Microsoft.Quantum.Arrays.*;

operation Main() : Int {
    use qubits = Qubit[3];
    ApplyToEach(H, qubits);
    Message("The qubit register in a uniform superposition: ");
    DumpMachine();
    let result = ForEach(M, qubits);
    Message("Measuring the qubits collapses the superposition to a basis state.");
    DumpMachine();
    ResetAll(qubits);
    return BoolArrayAsInt(ResultArrayAsBoolArray(result));
}
```
Hier ziet u drie concepten:
- De variabele qubits vertegenwoordigt nu een matrix Qubit die een lengte van drie heeft.
- De bewerkingen ApplyToEach en ForEach zijn handig om meerdere qubits te meten en erop te reageren en ze gebruiken minder code. Q#-bibliotheken bieden verschillende soorten bewerkingen en functies die het schrijven van kwantumprogramma's efficiënter maken.
- De BoolArrayAsInt en ResultArrayAsBoolArray functies uit de Microsoft.Quantum.Convert bibliotheek transformeren de binaire Result matrix die wordt geretourneerd in ForEach(M, qubits) een geheel getal.
Als u het programma wilt uitvoeren, klikt u op Uitvoeren boven de bewerking of drukt u op Main. Uw uitvoer wordt weergegeven in de console voor foutopsporing.

Door DumpMachine te gebruiken, ziet u hoe het meten van de drie qubits de status van het register doet instorten tot een van de acht mogelijke basisstatussen. Als u bijvoorbeeld het resultaat 3krijgt, betekent dit dat de status van het register is samengevouwen tot $|110\rangle$.

The qubit register in a uniform superposition:

DumpMachine:

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
 |000⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |001⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |010⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |011⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |100⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |101⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |110⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |111⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000

Measuring the qubits collapses the superposition to a basis state.

DumpMachine:

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
 |110⟩ |  1.0000+0.0000𝑖 |   100.0000% |   0.0000

Result: "3"

Notitie

De uitvoer kan verschillen omdat de generator voor willekeurige getallen probabilistisch is. De waarschijnlijkheden van de resultaten zijn niet deterministisch.

De bewerking ForEach(M, qubit) meet elk qubit op zijn beurt, waardoor de status geleidelijk instort. U kunt de tussenliggende toestanden ook dumpen na elke meting. Hiervoor wijzigt u Main.qs zoals in het volgende voorbeeld en slaat u het bestand op.

import Microsoft.Quantum.Diagnostics.*;
import Microsoft.Quantum.Measurement.*;
import Microsoft.Quantum.Math.*;
import Microsoft.Quantum.Convert.*;

operation Main() : Int {
    use qubits = Qubit[3];
    ApplyToEach(H, qubits);
    Message("The qubit register in a uniform superposition: ");
    DumpMachine();
    mutable results = [];
    for q in qubits {
        Message(" ");
        set results += [M(q)];
        DumpMachine();
    }
    Message(" ");
    Message("Your random number is: ");
    ResetAll(qubits);
    return BoolArrayAsInt(ResultArrayAsBoolArray(results));
}