Zelfstudie: Een kwantumgenerator voor willekeurige getallen implementeren in Q#

In deze zelfstudie schrijft u uw eerste kwantumprogramma met behulp van de Quantum Development Kit (QDK). Een eenvoudig voorbeeld van een kwantumalgoritme dat is geschreven in Q# is een kwantumgenerator voor willekeurige getallen. Dit algoritme maakt gebruik van de aard van kwantummechanismen om een willekeurig getal te produceren.

Vereisten

• Installeer de Quantum Development Kit (QDK) met behulp van de taal en ontwikkelomgeving van uw voorkeur.
• Als u de QDK al hebt geïnstalleerd, moet u ervoor zorgen dat u hebt bijgewerkt naar de nieuwste versie.

In deze zelfstudie leert u het volgende:

Een Q# project maken

Het eerste wat u moet doen, is een nieuw Q# project maken. In deze zelfstudie wordt de omgeving gebruikt op Q# basis van toepassingen met VS Code,maar u kunt uw favoriete IDE gebruiken.

Een nieuw project maken in VS Code:

1. Klik op Weergave -> Opdrachtpallet en selecteer Q#: Nieuw project maken.
2. Klik op Zelfstandige consoletoepassing.
3. Ga naar de locatie waar het project moet worden opgeslagen en klik op Project maken.
4. Klik rechtsonder op Nieuw project openen... als het project is gemaakt.

In dit geval heet het project Qrng . Hiermee worden twee bestanden gegenereerd: , het projectbestand en , een sjabloon van een toepassing die we gebruiken Qrng.csproj om onze toepassing te Program.qs Q# schrijven. De inhoud van Program.qs moet zijn:

   namespace Qrng {

      open Microsoft.Quantum.Canon;
      open Microsoft.Quantum.Intrinsic;
      
      @EntryPoint()
      operation HelloQ() : Unit {
          Message("Hello quantum world!");
      }
   }

Een Q-bewerking # schrijven

Vervang de inhoud van het bestand Program.qs door de volgende code:

namespace Qrng {
    open Microsoft.Quantum.Convert;
    open Microsoft.Quantum.Math;
    open Microsoft.Quantum.Measurement;
    open Microsoft.Quantum.Canon;
    open Microsoft.Quantum.Intrinsic;
    
    @EntryPoint()
    operation GenerateRandomBit() : Result {
        use q = Qubit();   // Allocate a qubit.
        H(q);              // Put the qubit to superposition. It now has a 50% chance of being 0 or 1.
        return MResetZ(q); // Measure the qubit value.
    }
}

Laten we deze code eens bekijken. U GenerateRandomBit definieert de bewerking , die geen invoer heeft en een waarde van het type Result produceert. Het type Result vormt het resultaat van een meting en kan twee mogelijke waarden hebben: Zero en One. EntryPoint vertelt de Q# compiler dat het programma hier moet worden uitgevoerd. In Q# worden qubits toegewezen via het use trefwoord . Met de bewerking H wordt de qubit in superpositie geplaatst. De M bewerking meet de qubit en retourneert de gemeten waarde (een nul of een één).

Zoals vermeld in het artikel Inzicht in kwantumcomputing, is een qubit een eenheid met kwantuminformatie die in superpositie kan zijn. Bij meting kan een qubit alleen 0 of 1 zijn. Vóór de meting vertegenwoordigt de toestand van de qubit echter de waarschijnlijkheid van het lezen van een 0 of een 1 met een meting. Deze waarschijnlijkheidstoestand staat bekend als superpositie. U kunt deze waarschijnlijkheid gebruiken om willekeurige getallen te genereren.

Deze Q# bewerking introduceert het Qubit gegevenstype, dat is eigen aan Q# . We kunnen een Qubit alleen toewijzen met een use-instructie. Wanneer een qubit wordt toegewezen, bevindt deze zich altijd in de toestand Zero.

Door de in superpositie te plaatsen met de bewerking en deze te meten met de intrinsieke bewerking, is het resultaat elke keer dat de code wordt aangeroepen een Qubit H andere M waarde.

Wanneer de toewijzing van een Qubit ongedaan wordt gemaakt, moet deze expliciet weer worden ingesteld op de toestand Zero, anders rapporteert de simulator een runtime-fout. Dit kan heel eenvoudig door Reset aan te roepen.

De code visualiseren met de Blochbol

In de Blochbol vertegenwoordigt de noordpool de klassieke waarde 0 en de zuidpool de klassieke waarde 1. Elke superpositie kan worden weergegeven met een punt op de bol (aangeduid met een pijl). Hoe dichter het einde van de pijl bij een pool is, hoe groter de kans is dat de qubit bij meting uiteenvalt in de klassieke waarde die aan die pool is toegewezen. De toestand van de qubit die wordt weergegeven door de rode pijl hieronder heeft bijvoorbeeld een hogere kans om de waarde 0 te retourneren als deze wordt gemeten.

We kunnen deze voorstelling gebruiken om te visualiseren wat de code doet:

• We beginnen met een qubit die is geïnitialiseerd in de toestand 0 en passen H toe om een superpositie te maken waarin de waarschijnlijkheid van 0 en 1 hetzelfde is.

• Vervolgens meten we de qubit en slaan we de uitvoer op:

Aangezien het resultaat van de meting volledig willekeurig is, hebben we een willekeurige bit verkregen. We kunnen deze bewerking meerdere keren aanroepen om gehele getallen te maken. Als we de bewerking bijvoorbeeld drie keer aanroepen om drie willekeurige bits te verkrijgen, kunnen we willekeurige 3-bits getallen maken (dat wil zeggen, een willekeurig getal tussen 0 en 7).

Een volledige generator voor willekeurige getallen maken

Nu u een bewerking hebt die willekeurige bits genereert, kunt u meerdere willekeurige bits combineren om een volledige kwantumgenerator voor Q# willekeurige getallen te bouwen. U kunt een toepassing Q# gebruiken of een hostprogramma gebruiken om dit te doen.

De logica definiëren voor de generator voor willekeurige getallen

Laten we eerst eens kijken wat de logica van een generator voor willekeurige getallen moet zijn, mits er al een random-bitgenerator bestaat:

1. maxDefinieer als het maximumaantal dat u wilt genereren.
2. Definieer het aantal willekeurige bits dat u moet genereren. Dit wordt gedaan door te berekenen hoeveel bits, , we nodig hebben om gehele getallen nBits tot maximaal uit te drukken.
3. Genereer een tekenreeks met een willekeurige nBits bitlengte.
4. Als de bit-tekenreeks een getal vormt dat groter is dan max, gaat u terug naar stap 3.
5. Is dat niet het geval, dan is het proces voltooid. Retourneer het gegenereerde getal als een geheel getal.

De bewerking definiëren

SampleRandomNumberInRangeDefinieer de bewerking, die de bewerking herhaaldelijk GenerateRandomBit aanroept om een tekenreeks met bits te bouwen.

Wijzig Program.qs als het volgende:

namespace Qrng {

    open Microsoft.Quantum.Canon;
    open Microsoft.Quantum.Intrinsic;
    open Microsoft.Quantum.Measurement;
    open Microsoft.Quantum.Math;
    open Microsoft.Quantum.Convert;

    operation GenerateRandomBit() : Result {
        // Allocate a qubit.
        use q = Qubit(); 
        // Put the qubit to superposition.
        H(q);
        // It now has a 50% chance of being measured 0 or 1.
        // Measure the qubit value.
        return M(q);
    }

    operation SampleRandomNumberInRange(max : Int) : Int {
        mutable output = 0; 
        repeat {
            mutable bits = new Result[0]; 
            for idxBit in 1..BitSizeI(max) {
                set bits += [GenerateRandomBit()]; 
            }
            set output = ResultArrayAsInt(bits);
        } until (output <= max);
        return output;
    }
}

Laten we nog even de nieuwe code controleren.

Om het aantal bits te berekenen dat nodig is om gehele getallen tot maximaal uit te drukken, biedt de bibliotheek de functie om Microsoft.Quantum.Math deze taak uit te BitSizeI voeren.

De bewerking maakt gebruik van een lus om willekeurige getallen te genereren totdat er een wordt gegenereerd die gelijk is aan of kleiner is SampleRandomNumberInRange repeat dan het maximum.

De for lus in werkt precies hetzelfde als een repeat for-lus in andere programmeertalen.

In dit voorbeeld zijn output en bits veranderlijke variabelen. Een veranderlijke variabele kan tijdens de berekening worden gewijzigd. U gebruikt de set-richtlijn om de waarde van een veranderlijke variabele te wijzigen.

De ResultArrayAsInt functie is afkomstig van de Microsoft.Quantum.Convert library . Met deze functie wordt de bit-tekenreeks geconverteerd naar een positief geheel getal.

Het Qrng programma kan nu willekeurige getallen genereren. Wijzig Program.qs als deze om het toegangspunt te definiëren.

namespace Qrng {

    open Microsoft.Quantum.Canon;
    open Microsoft.Quantum.Intrinsic;
    open Microsoft.Quantum.Measurement;
    open Microsoft.Quantum.Math;
    open Microsoft.Quantum.Convert;

    operation GenerateRandomBit() : Result {
        // Allocate a qubit.
        use q = Qubit();
        // Put the qubit to superposition.
        H(q);
        // It now has a 50% chance of being measured 0 or 1.
        // Measure the qubit value.
        return M(q);
    }

    operation SampleRandomNumberInRange(max : Int) : Int {
        mutable output = 0; 
        repeat {
            mutable bits = new Result[0]; 
            for idxBit in 1..BitSizeI(max) {
                set bits += [GenerateRandomBit()]; 
            }
            set output = ResultArrayAsInt(bits);
        } until (output <= max);
        return output;
    }

    @EntryPoint()
    operation SampleRandomNumber() : Int {
        let max = 50;
        Message($"Sampling a random number between 0 and {max}: ");
        return SampleRandomNumberInRange(max);
    }
}

dotnet build

dotnet run --no-build

import qsharp
from Qrng import SampleQuantumRandomNumberGenerator # We import the 
# quantum operation from the namespace defined in the file Qrng.qs
max = 50 # Here we set the maximum of our range
output = max + 1 # Variable to store the output
while output > max:
    bit_string = [] # We initialize a list to store the bits that
    # will define our random integer
    for i in range(0, max.bit_length()): # We need to call the quantum
        # operation as many times as bits are needed to define the
        # maximum of our range. For example, if max=7 we need 3 bits
        # to generate all the numbers from 0 to 7. 
        bit_string.append(SampleQuantumRandomNumberGenerator.simulate()) 
        # Here we call the quantum operation and store the random bit
        # in the list
    output = int("".join(str(x) for x in bit_string), 2) 
# Transform bit string to integer

print("The random number generated is " + str(output))
# We print the random number

$ python host.py
Preparing Q# environment...
..The random number generated is 42

using System;
using Microsoft.Quantum.Simulation.Core;
using Microsoft.Quantum.Simulation.Simulators;
using System.Linq;

namespace Qrng
{
    class Driver
    {
        static void Main(string[] args)
        {
            using (var sim = new QuantumSimulator())
            {
                // First we initialize all the variables:
                var bitString = "0"; // To save the bit string
                int max = 50; // The maximum of the range
                int size = Convert.ToInt32(Math.Floor(Math.Log(max, 2.0) + 1));
                // To calculate the amount of needed bits
                int output = max + 1; // Int to store the output
                while (output > max)  // Loop to generate the number
                {
                    bitString = "0"; // Restart the bit string if fails
                    bitString = String.Join("", Enumerable.Range(0, size).Select(idx =>
                        SampleQuantumRandomNumberGenerator.Run(sim).Result == Result.One ? "1" : "0"
                    ));
                    // Generate and concatenate the bits using the Q# operation
                    // Convert the bit string to an integer
                    output = Convert.ToInt32(bitString, 2);
                }
                // Print the result
                Console.WriteLine($"The random number generated is {output}.");
            }
        }
    }
}

$ dotnet run
The random number generated is 42

Volgende stappen

In de zelfstudie Q# Verstrengeling verkennen met ziet u hoe u een programma schrijft dat qubits bewerkt en meet en de effecten van Q# superpositie en verstrengeling demonstreert.

Het instellen Azure Quantum meer manieren om te leren Q# en kwantumprogrammeren aan te bevelen.