Øvelsesdel 2 – Opret en generator af tilfældige kvantetal

10 minutter

I denne enhed implementerer du den anden del af din kvantetilfældige talgenerator. Du kombinerer flere tilfældige bits for at danne et større tilfældigt tal. Denne del bygger på den tilfældige bitgenerator, som du allerede har oprettet i den forrige enhed.

Kombiner flere tilfældige bit for at danne et større tal

I den forrige enhed oprettede du en tilfældig bitgenerator, der sætter en qubit i en superpositionstilstand og derefter måler den qubit for at generere en tilfældig bitværdi på enten 0 eller 1, hver med 50% sandsynlighed. Værdien af denne bit er virkelig tilfældig, der er ingen måde at vide på forhånd, hvad måleresultatet vil være. Men hvordan kan du bruge denne funktionsmåde til at generere større tilfældige tal?

Hvis du gentager processen fire gange, kan du generere denne sekvens af binære cifre:

$${0, 1, 1, 0}$$

Hvis du kombinerer disse bits til en bitstreng, kan du danne et større tal. I dette eksempel svarer bitsekvensen ${0110}$ i binær til tallet 6 i decimal.

$${0110_{\ binær} \ækvivalent 6_{\ decimal}}$$

For at generere et vilkårligt stort tilfældigt tal skal du blot gentage denne proces mange gange. Kombiner derefter alle bitsene til et binært tal og konverter det binære tal til et decimaltal.

Definer logikken for generator af tilfældige tal

Før du skriver din Q#-kode, lad os skitsere logikken til at generere et tilfældigt tal:

Definer max som det maksimale decimaltal, du vil generere.
Bestem antallet af tilfældige bits, nBits, der kræves for at generere max.
Opret en tilfældig bitstreng, der er nBits i længden.
Hvis bitstrengen repræsenterer et tal, der er større end max, skal du gå tilbage til det forrige trin.
Ellers er processen fuldført. Returner det genererede tal som et decimalheltal.

Lad os for eksempel definere max til at være 12. Det vil sige, at 12 er det største tal, som din tilfældige talgenerator skal udsende.

Brug følgende ligning til at bestemme antallet af bit, der kræves for at repræsentere tallet 12 i binær:

$${\lfloor ln(12) / ln(2) + 1 \rfloor}$$

Ifølge denne ligning skal du bruge 4 bit for at repræsentere et tal mellem 0 og 12.

Antag f.eks., at du genererer en tilfældig bit fire gange og får bitstrengen ${1101_{\ binary}}$. Denne værdi i binær er lig med 13 i decimal. Da 13 er større end 12, skal du gentage processen.

Derefter genererer du bitstrengen ${0110_{\ binary}}$, som er lig med ${6_{\ decimal}}$. Da 6 er mindre end 12, er processen fuldført.

Generatoren af tilfældige kvantetal returnerer tallet 6.

Opret en komplet tilfældig talgenerator i Q#

Her udvider Main.qs du filen fra den forrige lektion for at opbygge din tilfældige talgenerator.

Importér de påkrævede biblioteker

Først skal du importere de navneområder fra Q#-standardbiblioteket, der indeholder de funktioner og handlinger, du skal bruge til at skrive programmet. Q#-compileren indlæser mange almindelige funktioner og handlinger automatisk. Men til kvantetilfældighedsgeneratoren har du brug for nogle yderligere funktioner og operationer fra to Q#-navnerum: Std.Math og Std.Convert.

Kopiér og indsæt følgende import direktiver i begyndelsen af filen Main.qs :

import Std.Convert.*;
import Std.Math.*;

Omdøb handlingen `Main` til `GenerateRandomBit`

Programmet til generator af tilfældige tal bruger den handling, Main du skrev i den forrige enhed, til at generere en tilfældig bit. Omdøb handlingen Main til GenerateRandomBit , så denne handling har et mere beskrivende navn og ikke er indgangspunktet til programmet.

Kopier og indsæt følgende kode i Main.qs:

import Std.Convert.*;
import Std.Math.*;

operation GenerateRandomBit() : Result {
    // Allocate a qubit.
    use q = Qubit();
    
    // Set the qubit into superposition of 0 and 1 using the Hadamard 
    H(q);
    
    // Measure the qubit and store the result.    
    let result = M(q);
    
    // Reset qubit to the |0〉 state.
    Reset(q);
    
    // Return the result of the measurement.
    return result;
}

Definer funktionen til generatoren af tilfældige tal

Opret en ny handling kaldet GenerateRandomNumberInRange. Denne handling kalder gentagne gange handlingen GenerateRandomBit for at oprette en streng af bits.

Kopier følgende kode, og placer den direkte før handlingen GenerateRandomBit i din Main.qs fil:

/// Generates a random number between 0 and `max`.
operation GenerateRandomNumberInRange(max : Int) : Int {
    // Determine the number of bits needed to represent `max` and store it
    // in the `nBits` variable. Then generate `nBits` random bits which will
    // represent the generated random number.
    mutable bits = [];
    let nBits = BitSizeI(max);
    for idxBit in 1..nBits {
        set bits += [GenerateRandomBit()];
    }

    let sample = ResultArrayAsInt(bits);
    
    // Return random number if it's within the requested range.
    // Generate it again if it's outside the range.
    return sample > max ? GenerateRandomNumberInRange(max) | sample;
}

Her er en oversigt over koden i GenerateRandomNumberInRange:

Kald BitSizeI funktionen fra Std.Math biblioteket for at beregne antallet af bit, der er nødvendige for at repræsentere det heltal, der er gemt i max.
Brug en for løkke til at generere et antal tilfældige bits lig med nBits. Kald din GenerateRandomBit operation for at generere de tilfældige bits.
Inde i løkken for skal du bruge sætningen set til at opdatere variablen bits med hver ny tilfældig bit. Variablen bits er en foranderlig variabel, hvilket betyder, at værdien af bits kan ændre sig under beregningen.
Kald ResultArrayAsInt funktionen fra Std.Convert biblioteket for at konvertere arrayet af bits til bits et positivt heltal, der er gemt i sample.
I erklæringen return skal du kontrollere, om sample er større end max. Hvis sample er større end max, så ring GenerateRandomNumberInRange igen og start forfra. Ellers skal du returnere det tilfældige tal, der er gemt i sample.

Tilføj et indgangspunkt

Til sidst skal du tilføje en indgangspunkthandling til din kode, så compileren kan køre dit program. Som standard søger Q#-kompilatoren efter en Main handling og bruger Main den som indgangspunkt, uanset hvor Main den er placeret i filen. Her Main indstiller operationen en værdi for max og kalder GenerateRandomNumberInRange handlingen for at generere et tilfældigt tal mellem 0 og max.

Hvis du f.eks. vil generere et tilfældigt tal mellem 0 og 100, skal du kopiere følgende kode til din Main.qs fil:

operation Main() : Int {
    let max = 100;
    Message($"Generating a random number between 0 and {max}: ");

    // Generate random number in the 0..max range.
    return GenerateRandomNumberInRange(max);
}

Endeligt program

Her er den komplette Q#-kode til dit program i Main.qs:

import Std.Convert.*;
import Std.Math.*;

operation Main() : Int {
    let max = 100;
    Message($"Generating a random number between 0 and {max}: ");
    
    // Generate random number in the 0..max range.
    return GenerateRandomNumberInRange(max);
}

/// Generates a random number between 0 and `max`.
operation GenerateRandomNumberInRange(max : Int) : Int {
    // Determine the number of bits needed to represent `max` and store it
    // in the `nBits` variable. Then generate `nBits` random bits which will
    // represent the generated random number.
    mutable bits = [];
    let nBits = BitSizeI(max);
    for idxBit in 1..nBits {
        set bits += [GenerateRandomBit()];
    }
    let sample = ResultArrayAsInt(bits);
    
    // Return random number if it's within the requested range.
    // Generate it again if it's outside the range.
    return sample > max ? GenerateRandomNumberInRange(max) | sample;
}
    
operation GenerateRandomBit() : Result {
    // Allocate a qubit.
    use q = Qubit();
    
    // Set the qubit into superposition of 0 and 1 using the Hadamard operation
    H(q);
    
    // Measure the qubit value using the `M` operation, and store the
    // measurement value in the `result` variable.
    let result = M(q);
    
    // Reset qubit to the |0〉 state.
    Reset(q);
    
    // Return the result of the measurement.
    return result;
}

Kør programmet

Prøv din nye kvantegenerator til tilfældige tal!

For at køre dit program skal du vælge Kør kodelinse fra listen over kommandoer over handlingen Main . Du kan også trykke på Ctrl + F5. Outputtet vises i fejlfindingskonsollen. Kør programmet flere gange og læg mærke til, hvordan resultatet ændrer sig.

Tillykke! Du oprettede en virkelig tilfældig kvantetalgenerator i Q#.

Bonusøvelse

Prøv at ændre programmet, så det også kræver, at det genererede tilfældige tal er større end et minimum positivt tal, mini stedet for nul.

Feedback

Var denne side nyttig?