Exerciții - Creați stări de superpoziție diferite cu Q#

  • 12 minute

În unitățile anterioare, ai învățat despre superpoziție și notația Dirac. Asta e destulă teorie pentru acum! Să scriem niște cod pentru a explora suprapoziția în Q#.

În această unitate, creați stări de superpoziție cuantică în Q# și explorați rolul probabilității în rezultatele măsurătorilor. De asemenea, utilizați DumpMachine funcția din Q# pentru a examina modul în care starea unui sistem se modifică în timpul unui calcul cuantic.

Creați un fișier Q# nou

  1. Deschideți Visual Studio Code (VS Code).
  2. Deschideți meniul Fișier , apoi alegeți Fișier text nou pentru a crea un fișier nou.
  3. Salvați fișierul ca Main.qs.

Introducere în superpoziție

Să începem cu un program simplu Q# care folosește un qubit într-o stare de superpoziție pentru a genera o valoare aleatorie a biților, 0 sau 1. În codul nostru, folosim DumpMachine funcția pentru a vedea starea qubitului în diferite puncte ale programului.

  1. Copiați și lipiți următorul cod în fișierul Main.qs :

    import Std.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;
}

  2. Pentru a rula programul pe simulatorul încorporat, alegeți obiectivul Run code deasupra operațiunii Main sau apăsați Ctrl + F5. Rezultatul apare în consola de depanare.

  3. Examinați consola de depanare pentru a găsi rezultatul măsurătorii, fie ZeroOne.

Funcția DumpMachine creează un tabel de informații care descrie starea sistemului cuantic, care în acest caz este un singur qubit. Informațiile de DumpMachine la includ amplitudinea probabilității, probabilitatea de măsurare și faza în radiani pentru fiecare stare de bază.

Codul apelează DumpMachine funcția de patru ori:

  • După ce alocați qubitul
  • După ce puneți qubitul într-o stare de suprapunere
  • După ce măsurați starea qubitului
  • După ce resetați qubitul

Să examinăm ieșirea de la fiecare apel la DumpMachine:

  • Qubit inițializat: Când alocați un qubit cu use instrucțiunea, qubitul începe întotdeauna în starea $|0\rangle$.

    Initialized qubit:

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

  • Qubit după aplicarea H: După ce aplicați H operația, qubitul este într-o stare de suprapunere egală, $|\psi\rangle=\frac1{\sqrt2} |0 unghi\r+ \frac1{\sqrt2} |1 unghi\r$.

    Qubit after applying H:

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
   |0⟩ |  0.7071+0.0000𝑖 |    50.0000% |   0.0000
   |1⟩ |  0.7071+0.0000𝑖 |    50.0000% |   0.0000

  • Qubit după măsurare: După ce măsurați qubitul, rezultatul este fie Zero sau One, iar qubitul este complet în starea pe care ați măsurat-o.

    Qubit after the measurement:

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

    Notă

    Rezultatul DumpMachine de după măsurare poate diferi de rezultatul de exemplu, deoarece aveți o șansă de 50% de a măsura fiecare stare. Probabilitățile rezultatelor sunt deterministe, dar rezultatul unei măsurători individuale nu este.

  • Qubit după resetare: Operația Reset resetează qubitul la starea $|0\rangle$, astfel încât să poată fi folosit din nou pentru calcule viitoare.

    Qubit after resetting:

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

Explorați alte stări de suprapunere

Acum că știți cum să inspectați starea unui sistem de qubiți cu DumpMachine, să explorăm alte operații care pun sistemul în diferite tipuri de stări de superpoziție.

Generatorul de biți aleatorii actuali produce fie Zero sau One cu o probabilitate de 50%. În exemplul următor, probabilitățile nu sunt egale.

Generator de biți aleatoriu nesecheat

Să presupunem că doriți să creați un generator de biți aleatori care este distorsionat, ceea ce înseamnă că probabilitatea de a obține Zero este diferită de probabilitatea de a obține One.

De exemplu, doriți rezultatul Zero cu probabilitatea $P$ și rezultatul One cu probabilitatea $1 - P$. Iată o stare de qubit validă care produce un astfel de generator de biți aleator:

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

Pentru această stare $|\psi\rangle$, $\alpha=\sqrt{P}$ și $\beta=\sqrt{1 - P}$ sunt amplitudinile de probabilitate ale stărilor de bază $|0\rangle$ și, respectiv, $|1\rangle$.

Pentru a obține această stare, puteți aplica secvențial operatorul $R_y(2\cos^{-1}\sqrt{P})$ la un qubit care începe în starea $|0\rangle$. Pentru a obține acest rezultat în Q#, utilizați din Ry biblioteca standard.

Sfat

Pentru a afla mai multe despre matematica din spatele operațiilor cu un singurqubit, consultați tutorialul Single-Qubit Gates în Katas quantum.

Pentru a crea o stare de suprapunere înclinată în Q#, urmați acești pași:

  1. Înlocuiți tot codul din Main.qs cu următorul exemplu, apoi salvați fișierul. Acest exemplu alege $\alpha$ să fie aproximativ $\frac13$.

    import Std.Diagnostics.*;
import Std.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.");
    DumpMachine(); // Dump the state of the qubit 
    Message("Your skewed random bit is:");
    let skewedrandomBit = M(q);
    Reset(q);
    return skewedrandomBit;
}

  2. Pentru a rula programul pe simulatorul încorporat, alegeți obiectivul Run code deasupra operațiunii Main sau apăsați Ctrl + F5. Rezultatul apare în consola de depanare.

  3. Examinați rezultatul DumpMachine și rezultatul măsurătorii dvs. De exemplu, rezultatul este similar cu următorul:

    The qubit is in the desired state.

 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:

One

Observați că probabilitatea unui Zero rezultat al măsurătorii este de aproximativ 33,33% și probabilitatea unui One rezultat este de aproximativ 66,67%. Acest generator de biți aleatori este înclinat spre One.

Notă

Rezultatul măsurătorii poate diferi de rezultatul de exemplu, deoarece generatorul de biți aleatori este probabilist. Probabilitățile rezultatelor sunt deterministe, dar rezultatul unei măsurători individuale nu este.

Superpoziție multi-qubit

Până acum, am luat în considerare doar sistemele cu un singur qubit. Dar un computer cuantic bun are nevoie de o mulțime de qubiți pentru a efectua calcule utile. Cum funcționează stările cuantice și suprapunerea atunci când sistemul nostru are mai mult de un qubit?

De exemplu, luați în considerare un sistem de trei qubiți. Fiecare qubit poate avea o valoare de 0 sau 1 atunci când îl măsurați, deci există opt stări posibile în care puteți găsi sistemul:

Unghi\r$|000\r,|001 unghi\r,|010 unghi\r,|011 unghi\r,|100 unghi\r,|101 unghi\r, unghi |110\r,|111\runghi $$

Există opt stări posibile pentru acest sistem, deoarece fiecare qubit poate fi independent fie 0, fie 1 atunci când luăm o măsurătoare. În general, numărul de stări posibile este egal cu $2^n$, unde $n$ este numărul de qubiți.

La fel ca în cazul unui singur qubit, o stare de suprapunere arbitrară pentru sistemul de 3 qubiți este reprezentată ca o sumă ponderată a acestor opt stări, unde ponderile sunt amplitudinile de probabilitate:

$$|\psi\runghi=\alpha_0|000\runghi+\alpha_1|001\runghi+\alpha_2|010\runghi+\alpha_3|011 alpha_3 Unghi\r+\alpha_4|100\runghi+\alpha_5|101\runghi+\alpha_6 |110\runghi+\alpha_7|111\runghi$$

Încă o dată, amplitudinile $\alpha_i$ sunt numere complexe care îndeplinesc condiția $\sum\limits_{i=0}^{i=7}|\alpha_i|^2=1$.

De exemplu, puteți plasa qubits într-o superpoziție uniformă, aplicând H la fiecare qubit. Apoi puteți utiliza această superpoziție uniformă pentru a crea un generator de numere aleatorii cuantice care generează numere de trei biți în loc de numere de un bit:

Starea de bază Număr
$\ket{000}$ 0
$\ket{001}$ 4
$\ket{010}$ 2
$\ket{011}$ 6
$\ket{100}$ 1
$\ket{101}$ 5
$\ket{110}$ 3
$\ket{111}$ 7

Notă

Modul standard de a scrie șiruri de biți este de a avea cea mai mică cifră în dreapta și cea mai mare cifră în stânga, la fel ca în cazul numerelor zecimale obișnuite. În Q# (și în multe alte limbaje de programare cuantică), ordinea este inversată, astfel încât cea mai mică cifră să fie în stânga și cea mai mare cifră să fie în dreapta. Deoarece DumpMachine funcția afișează stările cuantice în ordinea standard, numerele întregi zecimale cărora le corespund stările nu sunt ordonate secvențial de la 0 la $n-1$.

Pentru a crea acest tip de generator de numere aleatorii, urmați acești pași:

  1. Înlocuiți codul din Main.qs cu următorul exemplu, apoi salvați fișierul:

    import Std.Diagnostics.*;
import Std.Convert.*;

operation Main() : Int {
    use qubits = Qubit[3];
    ApplyToEach(H, qubits);
    Message("The qubit register in a uniform superposition: ");
    DumpMachine();
    let result = MeasureEachZ(qubits);
    Message("Measuring the qubits collapses the superposition to a basis state.");
    DumpMachine();
    ResetAll(qubits);
    return ResultArrayAsInt(result);
}

  2. Pentru a rula programul pe simulatorul încorporat, alegeți obiectivul Run code deasupra operațiunii Main sau apăsați Ctrl + F5. Rezultatul apare în consola de depanare.

  3. Examinați rezultatul DumpMachine și rezultatul măsurătorii dvs. De exemplu, rezultatul este similar cu următorul:

    The qubit register in a uniform superposition: 

 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.

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

6

    Notă

    Rezultatul tău are probabil un rezultat diferit de rezultatul exemplului, deoarece generatorul de numere aleatorii este probabilistic. Probabilitățile rezultatelor sunt deterministe, dar rezultatul unei măsurători individuale nu este.

Pentru a lucra cu mai mulți qubiți, codul Q# are următoarele modificări:

  • Variabila qubits reprezintă acum o matrice Qubit care are o lungime de trei.
  • Operațiile ApplyToEach și MeasureEachZ aplică operații cuantice la mai mulți qubiți cu o singură linie de cod. Bibliotecile Q# oferă multe funcții și operații care simplifică programarea cuantică pentru dvs.
  • Funcția ResultArrayAsInt din Std.Convert bibliotecă transformă matricea binară Result într-un număr întreg zecimal.

Rezultatul de DumpMachine la arată că actul de măsurare prăbușește starea de suprapunere într-una dintre cele opt stări de bază posibile, la fel ca în cazul unui singur qubit. De exemplu, dacă obțineți rezultatul 6, atunci înseamnă că starea sistemului s-a prăbușit la $|011\rangle$.

Acum să aruncăm o privire mai profundă asupra modului în care sistemul se schimbă pe măsură ce măsurăm fiecare qubit. Codul precedent a folosit operația MeasureEachZ pentru a măsura toți cei trei qubiți simultan. În schimb, să folosim o for buclă pentru a măsura qubiții pe rând și să folosim DumpMachine pentru a vizualiza starea sistemului după fiecare măsurătoare.

  1. Înlocuiți codul din Main.qs cu următorul exemplu, apoi salvați fișierul:

    import Std.Diagnostics.*;
import Std.Convert.*;

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

  2. Pentru a rula programul pe simulatorul încorporat, alegeți obiectivul Run code deasupra operațiunii Main sau apăsați Ctrl + F5. Rezultatul apare în consola de depanare.

  3. Examinați rezultatul DumpMachine și rezultatul măsurătorii dvs.

Rezultatul arată cum fiecare măsurătoare consecutivă schimbă starea cuantică și, prin urmare, probabilitățile de a obține fiecare rezultat. De exemplu, să examinăm fiecare parte a ieșirii în cazul în care rezultatul este 5:

  • Pregătirea stării: Sistemul este într-o stare de suprapunere egală după ce aplicați H fiecărui qubit.

    The qubit register is in a uniform superposition: 

 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

  • Prima măsurare: Rezultatul este One pentru prima măsurătoare, așa că acum singurele stări posibile în care poate ajunge sistemul sunt stările în care bitul cel mai din stânga este 1. Amplitudinile stărilor în care qubitul cel mai din stânga este 0 au dispărut, iar probabilitățile stărilor posibile rămase cresc de la 12,5% la 25,0% astfel încât suma probabilităților rămâne 100%.

     Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
 |100⟩ |  0.5000+0.0000𝑖 |    25.0000% |   0.0000
 |101⟩ |  0.5000+0.0000𝑖 |    25.0000% |   0.0000
 |110⟩ |  0.5000+0.0000𝑖 |    25.0000% |   0.0000
 |111⟩ |  0.5000+0.0000𝑖 |    25.0000% |   0.0000

  • A doua măsurare: Rezultatul este Zero pentru a doua măsurătoare, așa că acum singurele stări posibile în care poate ajunge sistemul sunt stările în care cei doi biți din stânga sunt 10. Acum rămânem cu doar două rezultate posibile atunci când măsurăm al treilea qubit, cu o probabilitate de 50% pentru fiecare rezultat.

     Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
 |100⟩ |  0.7071+0.0000𝑖 |    50.0000% |   0.0000
 |101⟩ |  0.7071+0.0000𝑖 |    50.0000% |   0.0000

  • A treia măsurătoare: În a treia măsurătoare, rezultatul este One. Sistemul este complet măsurat și, prin urmare, nu mai este într-o stare de suprapoziție, așa cum era de așteptat.

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

Your random number is: 

5

Cu Q#, puteți crea un sistem de qubiți, puteți pune qubiții într-o stare de superpoziție și puteți examina modul în care sistemul se schimbă pe măsură ce aplicați operații cuantice sau efectuați măsurători.