Øvelse – opret forskellige tilstande for superposition med Q#

  • 12 minutter

I de forrige enheder lærte du om overlejring og diracnotation. Det er nok teori for nu! Lad os skrive noget kode for at udforske superposition i Q#.

I denne enhed opretter du kvantesuperpositionstilstande i Q# og udforsker sandsynlighedsgradens rolle i måleresultater. Du kan også bruge DumpMachine funktionen i Q# til at undersøge, hvordan et systems tilstand ændres under en kvanteberegning.

Opret en ny Q#-fil

  1. Åbn Visual Studio Code (VS Code).
  2. Åbn menuen Filer , og vælg derefter Ny tekstfil for at oprette en ny fil.
  3. Gem filen som Main.qs.

Kom i gang med superposition

Lad os starte med et simpelt Q#-program, der bruger en qubit i en superpositionstilstand til at generere en tilfældig bitværdi, 0 eller 1. I vores kode bruger DumpMachine vi funktionen til at se qubittens tilstand på forskellige punkter i programmet.

  1. Kopiér og indsæt følgende kode i filen 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. For at køre dit program på den indbyggede simulator skal du vælge Kør kodelinsen over handlingen Main eller trykke på Ctrl + F5. Dit output vises i fejlfindingskonsollen.

  3. Undersøg fejlfindingskonsollen for at finde resultatet af din måling, enten Zero eller One.

Funktionen DumpMachine opretter en tabel med oplysninger, der beskriver kvantesystemets tilstand, som i dette tilfælde er en enkelt qubit. Oplysninger fra DumpMachine inkluderer sandsynlighedsamplituden, målesandsynligheden og fasen i radianer for hver basistilstand.

Din kode kalder DumpMachine funktionen fire gange:

  • Når du har tildelt qubitten
  • Når du har sat qubitten i en superpositionstilstand
  • Når du har målt qubittens tilstand
  • Når du har nulstillet qubit

Lad os undersøge outputtet fra hvert opkald til DumpMachine:

  • Initialiseret qubit: Når du tildeler en qubit med sætningen use , starter qubitten altid i tilstanden $|0\rangle$.

    Initialized qubit:

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

  • Qubit efter påføring af H: Når du har anvendt handlingen H , er qubitten i en lige superpositionstilstand, $|\psi\rangle=\frac1{\sqrt2} |0\rvinkel + \frac1{\sqrt2} |1\rvinkel$.

    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 efter målingen: Når du har målt qubitten, er resultatet enten Zero eller One, og qubitten er fuldt ud i den tilstand, du målte.

    Qubit after the measurement:

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

    Seddel

    Dit output fra DumpMachine efter måling kan afvige fra eksemplet, fordi du har 50% chance for at måle hver tilstand. Sandsynligheden for resultaterne er deterministisk, men resultatet af en individuel måling er det ikke.

  • Qubit efter nulstilling: Handlingen Reset nulstiller qubitten til tilstanden $|0\rangle$, så den kan bruges igen til fremtidige beregninger.

    Qubit after resetting:

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

Udforsk andre superpositionstilstande

Nu hvor du ved, hvordan du inspicerer tilstanden af et qubit-system med DumpMachine, lad os udforske andre operationer, der sætter systemet i forskellige slags superpositionstilstande.

Den nuværende tilfældige bitgenerator producerer enten Zero eller One med en sandsynlighed på 50%. I det næste eksempel er sandsynlighederne ikke ens.

Tilfældig bitgenerator med skråtstillet

Antag, at du vil oprette en tilfældig bitgenerator, der er skæv, hvilket betyder, at sandsynligheden for at få Zero er forskellig fra sandsynligheden for at få One.

For eksempel vil du have resultatet Zero med sandsynlighed $P$ og resultatet One med sandsynlighed $1 - P$. Her er en gyldig qubit-tilstand, der producerer en sådan tilfældig bitgenerator:

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

For denne tilstand er $|\psi\rvinkel$, $\alpha=\sqrt{P}$ og $\beta=\sqrt{1 - P}$ sandsynlighedsamplituderne for grundtilstandene $|0\rvinkel$ og $|1\rvinkel$, henholdsvis.

Hvis du vil opnå denne tilstand, kan du sekventielt anvende operatoren $R_y(2\cos^{-1}\sqrt{P})$ på en qubit, der starter i tilstanden $|0\rangle$. Hvis du vil opnå dette resultat i Q#, skal du bruge Ry fra standardbiblioteket.

Drikkepenge

Hvis du vil vide mere om matematikken bag single-qubit-handlinger, kan du se selvstudiet Single-Qubit Gates i Quantum Katas.

Hvis du vil oprette en skæv superpositionstilstand i Q#, skal du følge disse trin:

  1. Erstat al koden i Main.qs med følgende eksempel, og gem derefter filen. I dette eksempel vælges $\alpha$ til at være ca. $\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. For at køre dit program på den indbyggede simulator skal du vælge Kør kodelinsen over handlingen Main eller trykke på Ctrl + F5. Dit output vises i fejlfindingskonsollen.

  3. Undersøg outputtet fra DumpMachine og resultatet af din måling. Outputtet ligner f.eks. følgende:

    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

Bemærk, at sandsynligheden for et Zero måleresultat er omkring 33,33% og sandsynligheden for et One resultat er omkring 66,67%. Denne tilfældige bit-generator er skæv mod One.

Seddel

Dit måleresultat kan afvige fra eksempeloutputtet, fordi tilfældige bitgeneratoren er sandsynligvis. Sandsynligheden for resultaterne er deterministisk, men resultatet af en individuel måling er det ikke.

Multi-qubit-superposition

Indtil videre har vi kun overvejet single-qubit-systemer. Men en god kvantecomputer har brug for mange qubits for at udføre nyttige beregninger. Hvordan fungerer kvantetilstande og superposition, når vores system har mere end én qubit?

Overvej et eksempel et system med tre qubits. Hver qubit kan have en værdi på 0 eller 1, når du måler dem, så der er otte mulige tilstande, som du kan finde det system, du skal være i:

$$|000\rvinkel,|001\rvinkel,|010\rvinkel,|011\rvinkel,|100\rvinkel,|101\rvinkel, |110\rvinkel,|111\rvinkel $$

Der er otte mulige tilstande for dette system, fordi hver qubit uafhængigt kan være enten en 0 eller 1 tilstand, når vi foretager en måling. Generelt er antallet af mulige tilstande lig med $2^n$, hvor $n$ er antallet af qubits.

Ligesom med en enkelt qubit repræsenteres en vilkårlig superpositionstilstand for 3-qubit-systemet som en vægtet sum af disse otte tilstande, hvor vægtene er sandsynlighedsamplituderne:

$$|\psi\rvinkel=\alpha_0|000\rvinkel+\alpha_1|001\rvinkel+\alpha_2|010\rvinkel+\alpha_3|011\ralpha_3 vinkel+\alpha_4|100\rvinkel+\alpha_5|101\rvinkel+\alpha_6 |110\rvinkel+\alpha_7|111\rvinkel$$

Endnu en gang er amplituderne $\alpha_i$ komplekse tal, der opfylder betingelsen $\sum\limits_{i=0}^{i=7}|\alpha_i|^2=1$.

Du kan f.eks. placere qubits i en ensartet superposition ved at anvende H på hver qubit. Du kan derefter bruge denne ensartede superposition til at oprette en kvantetilfældig talgenerator, der genererer tre-bit-tal i stedet for en-bit-tal:

Grundlæggende tilstand Tal
$\ket{000}$ 0
$\ket{001}$ 4
$\ket{010}$ 2
$\ket{011}$ 6
$\ket{100}$ 1
$\ket{101}$ 5
$\ket{110}$ 3
$\ket{111}$ 7

Seddel

Standardmåden at skrive bitstrenge på er at have det mindste ciffer til højre og det største ciffer til venstre, ligesom med almindelige decimaltal. I Q# (og mange andre kvanteprogrammeringssprog) er rækkefølgen omvendt, så det mindste ciffer er til venstre og det største ciffer er til højre. Da DumpMachine funktionen viser kvantetilstande i standardrækkefølgen, er de decimalheltal, som tilstandene svarer til, ikke sorteret sekventielt fra 0 til $n-1$.

Følg disse trin for at oprette denne form for tilfældig talgenerator:

  1. Erstat din kode i Main.qs med følgende eksempel, og gem derefter filen:

    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. For at køre dit program på den indbyggede simulator skal du vælge Kør kodelinsen over handlingen Main eller trykke på Ctrl + F5. Dit output vises i fejlfindingskonsollen.

  3. Undersøg outputtet fra DumpMachine og resultatet af din måling. Outputtet ligner f.eks. følgende:

    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

    Seddel

    Dit output har sandsynligvis et andet resultat end eksempeloutputtet, fordi tilfældighedsgeneratoren er sandsynlig. Sandsynligheden for resultaterne er deterministisk, men resultatet af en individuel måling er det ikke.

Hvis du vil arbejde med flere qubits, har din Q#-kode følgende ændringer:

  • Variablen qubits repræsenterer nu en Qubit matrix, der har en længde på tre.
  • Handlingerne ApplyToEach og MeasureEachZ anvende kvantehandlinger på flere qubits med kun én kodelinje. Q#-bibliotekerne tilbyder mange funktioner og handlinger, der forenkler kvanteprogrammering for dig.
  • Funktionen ResultArrayAsInt fra Std.Convert biblioteket omdanner det binære Result array til et decimalheltal.

Outputtet fra DumpMachine viser, at målehandlingen kollapser superpositionstilstanden til en af de otte mulige basistilstande, ligesom med en enkelt qubit. For eksempel, hvis du får resultatet 6, så betyder det, at systemets tilstand kollapsede til $|011\rvinkel$.

Lad os nu se nærmere på, hvordan systemet ændrer sig, når vi måler hver qubit. Den foregående kode brugte operationen MeasureEachZ til at måle alle tre qubits på én gang. Lad os i stedet bruge en for løkke til at måle qubittene én ad gangen og bruge DumpMachine til at se systemets tilstand efter hver måling.

  1. Erstat koden i Main.qs med følgende eksempel, og gem derefter filen:

    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. For at køre dit program på den indbyggede simulator skal du vælge Kør kodelinsen over handlingen Main eller trykke på Ctrl + F5. Dit output vises i fejlfindingskonsollen.

  3. Undersøg outputtet fra DumpMachine og resultatet af din måling.

Outputtet viser, hvordan hver på hinanden følgende måling ændrer kvantetilstanden og dermed sandsynligheden for at opnå hvert resultat. Lad os for eksempel undersøge hver del af outputtet i tilfælde af, at dit resultat er 5:

  • Tilstandsforberedelse: Systemet er i en lige superpositionstilstand, når du har anvendt H på hver 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

  • Første måling: Resultatet er One for den første måling, så nu er de eneste mulige tilstande, som systemet kan ende i, de tilstande, hvor den længst venstre bit er 1. Amplituderne for de tilstande, hvor qubit længst til venstre er 0, er forsvundet, og sandsynligheden for de resterende mulige tilstande stiger fra 12,5% til 25,0%, så summen af sandsynligheder forbliver 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

  • Anden måling: Resultatet er Zero for den anden måling, så nu er de eneste mulige tilstande, som systemet kan ende i, de tilstande, hvor de to bits længst til venstre er 10. Nu står vi kun tilbage med to mulige udfald, når vi måler den tredje qubit, med en sandsynlighed på 50% for hvert udfald.

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

  • Tredje måling: I den tredje måling er Oneresultatet . Systemet er fuldt målt, og derfor ikke længere i en superpositionstilstand, som forventet.

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

Your random number is: 

5

Med Q# kan du oprette et system af qubits, sætte qubitsene i en superpositionstilstand og undersøge, hvordan systemet ændres, når du anvender kvanteoperationer eller foretager målinger.