Självstudier: Implementera en kvantgenerator för slumptal i Q#

I den här självstudien skriver du ditt första kvantprogram med hjälp av Quantum Development Kit (QDK). Ett enkelt exempel på en kvantalgoritm som skrivits i Q# är en kvantgenerator för slumptal. Den här algoritmen använder kvantmekanik till att generera ett slumptal.

Krav

• Installera Quantum Development Kit (QDK) med önskat språk och utvecklingsmiljö.
• Om du redan har installerat QDK kontrollerar du att du har uppdaterat till den senaste versionen.

I den här självstudien får du lära dig att:

Skapa ett Q# projekt

Det första du behöver göra är att skapa ett nytt Q# projekt. I den här självstudien används miljön Q# baserat på program med VS Code,men du kan använda önskad IDE.

Skapa ett nytt projekt i VS Code:

1. Klicka på Visa -> Kommandopalett och välj Q#: Skapa nytt projekt.
2. Klicka på Fristående konsolprogram.
3. Gå till platsen där du vill spara projektet och klicka på Skapa projekt.
4. När projektet har skapats klickar du på Öppna nytt projekt... längst ned till höger.

I det här fallet kallas projektet Qrng . Detta genererar två filer: Qrng.csproj , projektfilen och Program.qs , en mall för ett program som vi ska använda för att skriva Q# programmet. Innehållet i Program.qs ska vara:

   namespace Qrng {

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

Skriva en # Q-åtgärd

Ersätt innehållet i filen Program.qs med följande kod:

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.
    }
}

Låt oss ta en titt på den här koden. Du definierar GenerateRandomBit åtgärden, som inte tar några indata och genererar ett värde av typen Result . Typen Result representerar resultatet av en mätning och kan ha två möjliga värden: Zero och One. EntryPoint talar om Q# för kompilatorn att börja köra programmet här. I Q# allokeras qubitar via use nyckelordet . Åtgärden H placerar qubiten i superposition. Åtgärden M mäter qubiten och returnerar det uppmätta värdet (noll eller ett).

Som vi nämnde i artikeln Förstå kvantberäkning är en kvantbit en enhet med kvantinformation som kan vara i superposition. När den mäts kan kvantbiten endast vara antingen 0 eller 1. Men innan mätningen representerar tillståndet för qubiten sannolikheten att läsa antingen ett 0 eller ett 1 med en mätning. Detta sannolikhetstillstånd kallas för superposition. Du kan använda den här sannolikheten för att generera slumpmässiga tal.

Den Q# här åtgärden introducerar Qubit datatypen som är inbyggd i Q# . Vi kan bara allokera en Qubit med en use-instruktion. När den tilldelas är kvantbiten alltid i Zero-tillståndet.

Genom att placera i superposition med -åtgärden och mäta den med den inbyggda -åtgärden blir resultatet ett annat värde varje gång Qubit H koden M anropas.

När en Qubit har frigjorts måste den försättas i Zero-tillståndet igen. Annars rapporteras ett körningsfel i simulatorn. Ett enkelt sätt att göra detta på är att anropa Reset.

Visualisera koden med Bloch-sfären

I Bloch-sfären representerar nordpolen det klassiska värdet 0 och sydpolen det klassiska värdet 1. Alla superpositioner kan representeras av en punkt på sfären (visas med en pil). Ju närmare pilen är en pol, desto högre är sannolikheten att kvantbiten minimeras till det klassiska värde som tilldelades till polen när den mättes. Kvantbitstillståndet som representeras av den röda pilen nedan har till exempel en högre sannolikhet att ge värdet 0 om vi mäter det.

Vi kan använda den här representationen till att visualisera vad koden gör:

• Först börjar vi med en kvantbit som initierats i tillståndet 0. Vi använder H till att skapa en superposition där sannolikheten för 0 och 1 är densamma.

• Sedan mäter vi kvantbiten och sparar utdatan:

Eftersom resultatet av mätningen är helt slumpmässigt har vi fått en slumpmässig bit. Vi kan anropa den här åtgärden flera gånger för att skapa heltal. Om vi till exempel anropar åtgärden tre gånger för att få tre slumpmässiga bitar, kan vi bygga slumpmässiga 3-bitarstal (det vill säga ett slumptal mellan 0 och 7).

Skapa en komplett slumptalsgenerator

Nu när du har en åtgärd som genererar slumpmässiga bitar kan du kombinera flera slumpmässiga bitar för att skapa en komplett Q# kvantgenerator för slumptal. Du kan använda ett Q# program eller ett värdprogram för att göra det.

Definiera logiken för slumptalsgeneratorn

Först ska vi beskriva logiken för en slumptalsgenerator, förutsatt att det redan finns en generator för slumpmässiga bitar:

1. Definiera max som det maximala tal som du vill generera.
2. Definiera antalet slumpmässiga bitar som du behöver generera. Detta görs genom att beräkna hur många bitar, nBits , som vi behöver för att uttrycka heltal upp till max.
3. Generera en slumpmässig bitsträng som nBits är i längd.
4. Om bitsträngen representerar ett tal som är större än max går du tillbaka till steg tre.
5. I annat fall är processen slutförd. Returnera det genererade talet som ett heltal.

Definiera åtgärden

Definiera SampleRandomNumberInRange åtgärden, som upprepade gånger anropar GenerateRandomBit åtgärden för att skapa en sträng med bitar.

Ändra Program.qs så här:

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;
    }
}

Vi tar och går igenom den nya koden.

För att kunna beräkna antalet bitar som behövs för att uttrycka heltal upp till max, tillhandahåller biblioteket funktionen för Microsoft.Quantum.Math att utföra den här BitSizeI uppgiften.

Åtgärden SampleRandomNumberInRange använder en loop för att generera repeat slumpmässiga tal tills den genererar ett som är lika med eller mindre än max.

for-loopen i fungerar exakt likadant som en repeat for-loop i andra programmeringsspråk.

I det här exemplet är output och bits föränderliga variabler. Föränderliga variabler kan ändras under beräkningen. Du använder set-direktivet för att ändra värdet för en föränderlig variabel.

Funktionen ResultArrayAsInt kommer från Microsoft.Quantum.Convert library . Den här funktionen konverterar bitsträngen till ett positivt heltal.

Programmet Qrng kan nu generera slumpmässiga tal. Ändra Program.qs så här för att definiera startpunkten.

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

Nästa steg

I självstudien Q# Utforska sammanbrott med visas hur du skriver ett program som manipulerar och mäter qubits och visar effekterna av Q# superposition och sammanskar.

Konfigurera Azure Quantum fler sätt att lära sig Q# och kvantprogrammering.