Kurz: Implementace kvantového generátoru náhodných čísel v Q#

V tomto výukovém kurzu se naučíte, jak napsat jednoduchý kvantový program v Q#, který využívá principy kvantové mechaniky k vytvoření náhodného čísla.

V tomto kurzu:

• Vytvořte Q# program.
• Projděte si hlavní součásti Q# programu.
• Definujte logiku problému.
• Zkombinujte klasické a kvantové operace a vyřešte problém.
• Budete pracovat s qubity a superpozicí a vytvoříte kvantový generátor náhodných čísel.

Tip

Pokud chcete urychlit svou cestu k kvantovému computingu, podívejte se na kód pomocí Azure Quantum, který je jedinečnou funkcí webu Microsoft Quantum. Tady můžete spouštět předdefinované Q# ukázky nebo vlastní Q# programy, vygenerovat nový Q# kód z výzev, otevřít a spustit kód ve VS Code pro web jedním kliknutím a pokládat otázky copilotu týkající se kvantového computingu.

Požadavky

Pokud chcete spustit vzorový kód v Copilotu v Azure Quantum, musíte mít e-mailový účet Microsoft (MSA).

Pokud chcete vyvíjet a spouštět ukázku kódu v editoru Visual Studio Code (VS Code) a Jupyter Notebook, nainstalujte následující:

• Nejnovější verze VS Code nebo otevřít VS Code pro web.

• Nejnovější verze rozšíření Azure Quantum Development Kit (QDK). Podrobnosti o instalaci najdete v tématu Nastavení rozšíření QDK.

• Rozšíření Python a Jupyter pro VS Code

• Nejnovější qdk knihovna Python s jupyter rozšířením. Pokud je chcete nainstalovat, otevřete terminál a spusťte následující příkaz:

  pip install --upgrade "qdk[jupyter]"
  

Definování problému

Klasické počítače nevytvářejí náhodná čísla, ale spíše pseudonáhodná čísla. Generátor pseudonáhodných čísel generuje deterministickou sekvenci čísel na základě určité počáteční hodnoty, která se nazývá seed. K lepšímu přiblížení náhodných hodnot se jako seed často používá aktuální čas z hodin CPU.

Kvantové počítače můžou na druhé straně generovat skutečně náhodná čísla. Důvodem je, že měření qubitu v superpozici je pravděpodobnostní proces. Výsledek měření je náhodný a neexistuje způsob, jak předpovědět výsledek. Toto je základní princip generátorů kvantových náhodných čísel.

Qubit je jednotka kvantových informací, která může být v superpozici. Při měření může být qubit buď ve stavu 0, nebo ve stavu 1. Před měřením ale stav qubitu představuje pravděpodobnost, že pomocí měření přečteme buď 0 nebo 1.

Začnete tím, že vezmete qubit v základním stavu, například nulu. Prvním krokem generátoru náhodných čísel je použití operace Hadamard k vložení qubitu do stejné superpozice. Výsledkem měření tohoto stavu je nula nebo jedna s 50% pravděpodobností každého výsledku, což je skutečně náhodný bit.

Neexistuje způsob, jak zjistit, co získáte po měření qubitu v superpozici, a výsledek je jiná hodnota při každém vyvolání kódu. Jak ale můžete toto chování použít k vygenerování větších náhodných čísel?

Řekněme, že tento proces čtyřikrát zopakujeme, takže se vygeneruje tato posloupnost binárních číslic:

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

Pokud tyto bity zřetězíte nebo spojíte do bitového řetězce, můžete vytvořit větší číslo. V tomto příkladu odpovídá bitová sekvence ${0110}$ hodnotě šest v desítkové soustavě.

$${0110_{\ binary} \equiv 6_{\ decimal}}$$

Pokud tento proces opakujete mnohokrát, můžete zkombinovat více bitů a vytvořit libovolné velké číslo. Pomocí této metody můžete vytvořit číslo, které se použije jako zabezpečené heslo, protože můžete mít jistotu, že žádný hacker nemůže určit výsledky posloupnosti měření.

Definování logiky generátoru náhodných čísel

Pojďme si zpřesnit logiku generátoru náhodných čísel:

1. Definujte max jako maximální počet, který chcete vygenerovat.
2. Definujte počet náhodných bitů, které potřebujete vygenerovat. To se provádí výpočtem, kolik bitů, nBits, musíte vyjádřit celá čísla až max.
3. Vygenerujte náhodný bitový řetězec, který má délku nBits.
4. Pokud bitový řetězec představuje číslo větší než max, vraťte se ke kroku 3.
5. Tím je proces hotový. Vraťte vygenerované číslo jako celé číslo.

Příklad: Nastavíme hodnotu max na 12. To znamená, že 12 je největší číslo, které chcete použít jako heslo.

Potřebujete ${\lfloor ln(12) / ln(2) + 1 \rfloor}$ nebo 4 bity, aby představovaly číslo mezi 0 a 12. Můžeme použít předdefinované funkce BitSizeI, která přebírá jakékoli celé číslo a vrací počet bitů potřebných k jeho reprezentaci.

Řekněme, že vygenerujete bitový řetězec ${1101_{\ binary}}$, který odpovídá ${13_{\ decimal}}$. Protože 13 je větší než 12, proces se zopakuje.

Dále vygenerujete bitový řetězec ${0110_{\ binary}}$, který odpovídá ${6_{\ decimal}}$. Protože 6 je menší než 12, proces se dokončí.

Generátor kvantových náhodných čísel vrátí jako heslo číslo 6. V praxi nastavte větší číslo jako maximum, protože nižší čísla jsou snadné prolomit pouhým pokusem o všechna možná hesla. Ve skutečnosti můžete ke zvýšení složitosti hádání nebo prolomení hesla použít kód ASCII k převodu binárního souboru na text a k vygenerování hesla pomocí čísel, symbolů a smíšených písmen.

Napsat generátor náhodných bitů

Prvním krokem je napsat Q# operaci, která generuje náhodný bit. Tato operace bude jedním z stavebních bloků generátoru náhodných čísel.

operation GenerateRandomBit() : Result {
    // Allocate a qubit.
    use q = Qubit();

    // Set the qubit into superposition of 0 and 1 using the Hadamard 
    H(q);

    // At this point the qubit `q` has 50% chance of being measured in the
    // |0〉 state and 50% chance of being measured in the |1〉 state.
    // 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.
    // Qubits must be in the |0〉 state by the time they are released.
    Reset(q);

    // Return the result of the measurement.
    return result;
}

Teď se podívejte na nový kód.

• Definujete GenerateRandomBit operaci, která nepřijímá žádný vstup a vytváří hodnotu typu Result. Typ Result představuje výsledek měření a může mít dvě možné hodnoty: Zero nebo One.
• Přidělíte jeden qubit s klíčovým slovem use . Když je přidělen, qubit je vždy ve stavu |0〉.
• Pomocí H operace umístíte qubit do stejné superpozice.
• Tuto operaci použijete M k měření qubitu, vrátí naměřenou hodnotu (Zero nebo One).
• Pomocí Reset operace resetujete qubit do stavu |0〉.

Když umístíte qubit do superpozice s H operací a měříte ho operací M, výsledek je při každém vyvolání kódu odlišná hodnota.

Q# Vizualizace kódu pomocí Bloch sphere

V blochové kouli představuje severní pól klasickou hodnotu 0 a jižní pól představuje klasickou hodnotu 1. Každá superpozice může být reprezentována bodem na kouli (reprezentovaný šipkou). Čím blíž je konec šipky k pólu, tím vyšší je pravděpodobnost, že se qubit při změření převede na klasickou hodnotu přiřazenou k příslušnému pólu. Například stav qubitu reprezentovaný šipkou na následujícím obrázku má vyšší pravděpodobnost, že hodnotu 0 dáte, pokud ji změříte.

Pomocí této reprezentace můžete vizualizovat, co kód dělá:

1. Nejprve začněte s qubitem inicializovaným ve stavu |0〉 a pomocí H operace vytvořte stejnou superpozici, ve které jsou pravděpodobnosti 0 a 1 stejné.

   

2. Pak změřte qubit a uložte výstup:

   

Vzhledem k tomu, že výsledek měření je náhodný a pravděpodobnosti měření 0 a 1 jsou stejné, získali jste zcela náhodný bit. Tuto operaci můžete volat několikrát, abyste vytvořili celá čísla. Pokud například operaci zavoláte třikrát, abyste získali tři náhodné bity, můžete vytvořit náhodná 3bitová čísla (to znamená náhodné číslo v rozmezí od 0 do 7).

Napsání kompletního generátoru náhodných čísel

1. Nejprve je potřeba importovat požadované obory názvů ze Q# standardní knihovny do programu. Q# Kompilátor načte mnoho běžných funkcí a operací automaticky, ale pro kompletní generátor náhodných čísel potřebujete některé další funkce a operace ze dvou Q# oborů názvů: Std.Matha Std.Convert.

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

2. Dále definujete GenerateRandomNumberInRange operaci. Tato operace opakovaně volá operaci GenerateRandomBit pro sestavení řetězce bitů.

   /// 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 {
           bits += [GenerateRandomBit()];
       }
       let sample = ResultArrayAsInt(bits);
   
       // Return random number if it is within the requested range.
       // Generate it again if it is outside the range.
       return sample > max ? GenerateRandomNumberInRange(max) | sample;
   }
   
   

   Krátce si zrevidujme nový kód.

   • Potřebujete vypočítat počet bitů potřebných k vyjádření celých čísel až do max. Funkce BitSizeI z Std.Math oboru názvů převede celé číslo na počet bitů potřebných k jeho reprezentaci.
   • Operace SampleRandomNumberInRange používá smyčku for ke generování náhodných čísel, dokud nevygeneruje hodnotu, která je menší než nebo rovna max. Smyčka for funguje přesně stejně jako smyčka for v jiných programovacích jazycích.
   • Proměnná bits je proměnlivá proměnná. Měnitelná proměnná je taková, která se může během výpočtu změnit. Pomocí direktivy set můžete změnit hodnotu měnitelné proměnné.
   • Funkce ResultArrayAsInt z výchozího Std.Convert oboru názvů převede bitový řetězec na kladné celé číslo.

3. Nakonec do programu přidáte vstupní bod. Podle výchozího nastavení kompilátor Q# vyhledá operaci Main a začne ji tam zpracovávat. Volá operaci GenerateRandomNumberInRange, aby vygenerovala náhodné číslo mezi 0 a 100.

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

   Direktiva let deklaruje proměnné, které se během výpočtu nemění. Tady definujete maximální hodnotu jako 100.

   Další informace o Main operaci naleznete v tématu Vstupní body.

4. Úplný kód generátoru náhodných čísel je následující:

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

operation Main() : Int {
    let max = 100;
    Message($"Sampling 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 {
        bits += [GenerateRandomBit()];
    }
    let sample = ResultArrayAsInt(bits);

    // Return random number if it is within the requested range.
    // Generate it again if it is 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 a Hadamard operation
    H(q);

    // At this point the qubit `q` has 50% chance of being measured in the
    // |0〉 state and 50% chance of being measured in the |1〉 state.
    // 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.
    // Qubits must be in the |0〉 state by the time they are released.
    Reset(q);

    // Return the result of the measurement.
    return result;
}

Spuštění programu generátoru náhodných čísel

Program můžete spustit v Copilotu v Azure Quantum a v editoru Visual Studio Code jako samostatnou Q# aplikaci nebo pomocí hostitelského programu Pythonu.

Copilot v Azure Quantum

Svůj Q# kód můžete otestovat pomocí Copilotu v Azure Quantum zdarma – vše, co potřebujete, je e-mailový účet Microsoft (MSA). Další informace o copilotu v Azure Quantum najdete v tématu Prozkoumání Azure Quantum.

1. V prohlížeči otevřete Copilot v Azure Quantum.

2. Zkopírujte a vložte následující kód do editoru kódu.

   import Std.Convert.*;
   import Std.Math.*;
   
   operation Main() : Int {
       let max = 100;
       Message($"Sampling a random number between 0 and {max}: ");
   
       // Generate random number in the 0..max range.
       return GenerateRandomNumberInRange(max);
   }
   
   /// # Summary
   /// 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 {
           bits += [GenerateRandomBit()];
       }
       let sample = ResultArrayAsInt(bits);
   
       // Return random number if it is within the requested range.
       // Generate it again if it is outside the range.
       return sample > max ? GenerateRandomNumberInRange(max) | sample;
   }
   
   /// # Summary
   /// Generates a random bit.
   operation GenerateRandomBit() : Result {
       // Allocate a qubit.
       use q = Qubit();
   
       // Set the qubit into superposition of 0 and 1 using the Hadamard 
       // operation `H`.
       H(q);
   
       // At this point the qubit `q` has 50% chance of being measured in the
       // |0〉 state and 50% chance of being measured in the |1〉 state.
       // 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.
       // Qubits must be in the |0〉 state by the time they are released.
       Reset(q);
   
       // Return the result of the measurement.
       return result;
   
       // Note that Qubit `q` is automatically released at the end of the block.
   }
   
   

3. Vyberte počet snímků, které chcete spustit, a vyberte Spustit.

4. Výsledky se zobrazí v histogramu a v polích Výsledky .

5. Vyberte Vysvětlit kód, aby Copilot vysvětlil kód.

Tip

Z Copilotu ve službě Azure Quantum můžete program otevřít ve VS Code pro web výběrem tlačítka s logem VS Code v pravém rohu editoru kódu.

Q# program v editoru Visual Studio Code

1. V editoru Visual Studio Code otevřete nabídku Soubor a zvolte Nový textový soubor a vytvořte nový soubor.

2. Uložte soubor jako RandomNumberGenerator.qs. Tento soubor bude obsahovat Q# kód pro váš program.

3. Zkopírujte do RandomNumberGenerator.qs souboru následující kód.

   import Std.Convert.*;
   import Std.Math.*;
   
   operation Main() : Int {
       let max = 100;
       Message($"Sampling a random number between 0 and {max}: ");
   
       // Generate random number in the 0..max range.
       return GenerateRandomNumberInRange(max);
   }
   
   /// # Summary
   /// 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 {
           bits += [GenerateRandomBit()];
       }
       let sample = ResultArrayAsInt(bits);
   
       // Return random number if it is within the requested range.
       // Generate it again if it is outside the range.
       return sample > max ? GenerateRandomNumberInRange(max) | sample;
   }
   
   /// # Summary
   /// Generates a random bit.
   operation GenerateRandomBit() : Result {
       // Allocate a qubit.
       use q = Qubit();
   
       // Set the qubit into superposition of 0 and 1 using the Hadamard 
       // operation `H`.
       H(q);
   
       // At this point the qubit `q` has 50% chance of being measured in the
       // |0〉 state and 50% chance of being measured in the |1〉 state.
       // 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.
       // Qubits must be in the |0〉 state by the time they are released.
       Reset(q);
   
       // Return the result of the measurement.
       return result;
   
       // Note that Qubit `q` is automatically released at the end of the block.
   }
   

4. Program spustíte tak, že v seznamu předchozích příkazů vyberete Main() nebo stisknete Kombinaci kláves Ctrl+F5. Program spustí Main() operaci na výchozím simulátoru.

   

5. Výstup se zobrazí v konzole ladění.

6. Spusťte program znovu, abyste viděli jiný výsledek.

Poznámka:

Pokud profil QIR target není nastavený na Unrestricted, zobrazí se při spuštění programu chyba. Pro tento program kompilátor automaticky nastaví target profil na Unrestricted , pokud nenastavíte profil sami.

Vykreslete histogram četnosti

Pojďme vizualizovat distribuci výsledků získaných z vícenásobného spuštění kvantového programu. Histogram četnosti pomáhá vizualizovat rozdělení pravděpodobnosti těchto výsledků.

1. Vyberte Zobrazení –> Příkazová paleta a zadejte histogram, čímž se zobrazí příkaz QDK: Spustit soubor a zobrazit histogram. Můžete také vybrat Histogram ze seznamu příkazů předcházejících Main(). Tuto možnost vyberte, pokud chcete otevřít okno histogramu Q# .

   

2. Zadejte počet snímků pro spuštění programu, například 100 snímků, a stiskněte Enter. Histogram se zobrazí v okně histogramu Q# .

3. Každý pruh v histogramu odpovídá možnému výsledku a jeho výška představuje počet pozorovaných výsledků. Počet různých výsledků se může lišit při každém spuštění histogramu.

   

   Tip

   Histogram můžete přiblížit pomocí kolečka myši nebo gesta trackpadu. Při přiblížení můžete graf posunout stisknutím klávesy Alt při posouvání.

4. Výběrem pruhu zobrazíte procento tohoto výsledku.

5. Výběrem ikony nastavení vlevo nahoře zobrazíte možnosti. Můžete zobrazit 10 nejlepších výsledků, prvních 25 výsledků nebo všechny výsledky. Výsledky můžete také seřadit od vysokých po nízké nebo nízké až vysoké.

   

Poznámkový blok Jupyter ve VS Code

1. Ve VS Code vyberte > a vyberte Vytvořit: Nový poznámkový blok Jupyter.

2. V první buňce naimportujte balíček do kódu Pythonu qsharp :

   from qdk import qsharp
   

3. Q# Přidejte kód pro program kvantového generátoru náhodných čísel. K tomu použijete %%qsharp příkaz magic. Všimněte si, že %%qsharp příkaz změní buňku poznámkového bloku z typu Python na typ Q#. Zkopírujte tento kód do druhé buňky.

   %%qsharp
   
   import Std.Convert.*;
   import Std.Math.*;
   
   operation Main() : Int {
       let max = 100;
   
       // Generate random number in the 0..max range.
       return GenerateRandomNumberInRange(max);
   }
   
   /// # Summary
   /// 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 {
           bits += [GenerateRandomBit()];
       }
       let sample = ResultArrayAsInt(bits);
   
       // Return random number if it is within the requested range.
       // Generate it again if it is outside the range.
       return sample > max ? GenerateRandomNumberInRange(max) | sample;
   }
   
   /// # Summary
   /// Generates a random bit.
   operation GenerateRandomBit() : Result {
       // Allocate a qubit.
       use q = Qubit();
   
       // Set the qubit into superposition of 0 and 1 using the Hadamard 
       // operation `H`.
       H(q);
   
       // At this point the qubit `q` has 50% chance of being measured in the
       // |0〉 state and 50% chance of being measured in the |1〉 state.
       // 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.
       // Qubits must be in the |0〉 state by the time they are released.
       Reset(q);
   
       // Return the result of the measurement.
       return result;
   
       // Note that Qubit `q` is automatically released at the end of the block.
   }
   

4. Nakonec spusťte kód. Stejnou simulaci můžete spustit několikrát nezávisle. Každá nezávislá simulace se nazývá „výstřel“. Pojďme například spustit simulaci 100krát.

   results = qsharp.run("Main()", shots=100)
   print(results)
   

Poznámka:

Tento fragment kódu se momentálně nespouští na žádném dostupném hardwaru targetsAzure Quantum, protože volatelný ResultArrayAsInt vyžaduje QPU s úplným výpočetním profilem.

Související obsah

Prozkoumejte další Q# kurzy:

• Kvantové propletení ukazuje, jak napsat Q# program, který manipuluje s qubity a měří je a ukazuje účinky superpozice a propletení.
• Groverův vyhledávací algoritmus ukazuje, jak napsat Q# program, který používá Groverův vyhledávací algoritmus.
• Quantum Fourier Transforms zkoumá, jak napsat Q# program, který přímo řeší konkrétní qubity.
• Kvantové katy jsou kurzy a programovací cvičení zaměřená na výuku prvků kvantového computingu a Q# programování současně.