This blog focusses on building a Quantum Random Number Generator (QRNG) with Q#. In following sections, we will: Give an overview of the current status of Quantum Computing today Lightly discuss basic concepts surrounding quantum qubits: quantum entanglement, Superposition, and Decoherence Relate superposition to the “Bloch Sphere” Obtain a random value by measuring a qubit in superposition Present a Q# (QRNG) that generates numbers to the console:This blog focusses on building a Quantum Random Number Generator (QRNG) with Q#. In following sections, we will: Give an overview of the current status of Quantum Computing today Lightly discuss basic concepts surrounding quantum qubits: quantum entanglement, Superposition, and Decoherence Relate superposition to the “Bloch Sphere” Obtain a random value by measuring a qubit in superposition Present a Q# (QRNG) that generates numbers to the console:
Q# is een statisch getypeerde mix van C# en F#. Een type volgt op een declaratie, maar kan worden weggelaten als typeafleiding tijdens het compileren dit toelaat.

De bewerking Q# Quantum Random Number Generator volgt. Het moet leesbaar zijn voor JavaScript-, C#-, Golang- of Java-programmeurs.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
   operation QuantumRandomNumberGenerator() : Int { 
      mutable randomNumber = 0;

// Accumulate 64 random bits, right-to-left,
// each taken per-step from a single qubit       
for (i in 1 .. 64) {                 

using(q = Qubit()) { // Allocate single qubit.
    H(q);     // Hadamard gate moves qubit into superposition.
    let res = M(q);  // Measure qubit: a 50% chance of seeing 0 or 1 

// Accumulate to sliding bit sequence               
set randomNumber = LeftShiftedI(randomNumber, 1);
               if (res == One) {
set randomNumber = Or(randomNumber, 1);
               }
               Reset(q);  // We must reset released qubits
           }
       }
       return randomNumber;
   }

De code van deze bewerking is afkomstig uit de Quickstart QRN van Microsoft. We raden u aan deze pagina te lezen voor meer informatie over de relevantie ervan voor de Bloch-bol.

De centrale logica is:

Verkrijg een enkele qubit via een Q#-instructie met behulp van
Stuur het naar een Hadamard-kwantumpoort die de qubit invoert en terugstuurt naar de superpositiestatus
Meet de qubit, waarbij de superpositie wordt samengevouwen tot een willekeurige concrete toestand
De kwantumactie concentreert zich op dit fragment dat werkt op qubit, q:

1
2
H(q);           // Hadamard gate moves qubit into superposition.
let res = M(q); // Measure the qubit value: a 50% chance of seeing 0 or 1.

Q# kan ook klassieke bewerkingen uitvoeren. Onze operatie verzamelt een willekeurig geheel getal van 64 bits door herhaaldelijk één qubit in superpositie te plaatsen en vervolgens te meten. Ons aanroepende C#-stuurprogramma verzamelt tien van die Q#-gegenereerde 64-bits gehele getallen, en logt elk in de console

1
2

3
4
5
6
7
8
// C#: Gen random numbers
Console.WriteLine($"{ResultCount} Q#-generated 64-bit random integers:");
for (var d = 0; d < ResultCount; d++)
{   
// Call q# processing here   
var res = QuantumRandomNumberGenerator.Run(quantumSimulator).Result;   
Console.WriteLine("{0,20:X16}", res);
}

Bouwen en uitvoeren
Het kan nuttig zijn om het project op gitHub te bekijken. Bekijk hem door hier te klikken.

afhankelijkheden
Een Linux-, MacOS- of Windows-systeem waarop .NET Core kan worden uitgevoerd
.NET Core 3 (de onze is 3.0.101)
Installatie
.NET core maakt dit gemakkelijk op Windows, Linux of MacOS, geen IDE nodig. Voer de volgende stappen uit:

dotnet nieuw -i Microsoft.Quantum.ProjectTemplates
git kloon https://github.com/mauget/QSharp-Random-Gen
Controleer of de gekloonde directorystructuur deze is:

Door quantum

Geef een reactie

Je e-mailadres wordt niet gepubliceerd. Vereiste velden zijn gemarkeerd met *