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

Poznámka

Microsoft Quantum Development Kit (Classic QDK) už nebude po 30. červnu 2024 podporován. Pokud jste stávající vývojář sady QDK, doporučujeme přejít na novou verzi Azure Quantum Development Kit (moderní sada QDK) a pokračovat ve vývoji kvantových řešení. Další informace najdete v tématu Migrace Q# kódu do moderní sady QDK.

Naučte se napsat základní kvantový program, Q# který využívá povahu kvantové mechaniky k vytvoření náhodného čísla.

V tomto kurzu:

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

Tip

Pokud chcete zrychlit cestu k kvantovému computingu, podívejte se na kódování pomocí Azure Quantum, jedinečné funkce webu Azure Quantum. Tady můžete spouštět integrované Q# ukázky nebo vlastní Q# programy, generovat nový Q# kód z výzev, otevírat a spouštět kód v editoru VS Code pro web jedním kliknutím a pokládat společnosti Copilot jakékoli otázky týkající se kvantových výpočtů.

Požadavky

• Spuštění ukázky kódu v souboru Copilot ve službě Azure Quantum:

  • E-mailový účet Microsoft (MSA).

• Vývoj a spuštění ukázky kódu v editoru Visual Studio Code:

  • Nejnovější verze editoru Visual Studio Code nebo otevřete VS Code na webu.

  • Nejnovější verze rozšíření Azure Quantum Development Kit . Podrobnosti o instalaci najdete v tématu Instalace moderní sady QDK ve VS Code.

  • Pokud chcete používat poznámkové bloky Jupyter, musíte také nainstalovat Python, rozšíření Jupyter a nejnovější qsharp balíček Pythonu. Uděláte to tak, že otevřete terminál a spustíte následující příkaz:

    $ pip install --upgrade  qsharp
    

Definování problému

Klasické počítače nevytvářejí náhodná čísla, ale pseudonáhodná čísla. Generátor pseudonáhodných čísel generuje deterministickou sekvenci čísel na základě nějaké počáteční hodnoty, která se nazývá počáteční hodnota. Aby se počáteční hodnota přiblížila náhodné hodnotě, používá často aktuální čas z procesoru.

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

Qubit je jednotka kvantové informace, která může být v superpozici. Při měření může být qubit buď ve stavu 0 , nebo 1 . Stav qubitu však před měřením představuje pravděpodobnost , že se při měření načtou hodnoty 0 nebo 1 .

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

Neexistuje způsob, jak zjistit, co získáte po měření qubitu v superpozici, a výsledkem je při každém vyvolání kódu jiná hodnota. Jak ale můžete toto chování použít ke generová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 tak libovolné velké číslo. Nyní můžete svému nadřízenému poskytnout toto číslo jako bezpečné heslo, protože si můžete být jisti, že žádný hacker prostoru nemůže určit výsledky posloupnosti měření.

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

Pojďme si nastínit, jaká by měla být logika generátoru náhodných čísel, pokud máme generátor náhodných bitů:

1. Definujte max jako maximální počet, který chcete vygenerovat.
2. Definujte počet náhodných bitů, které potřebujete vygenerovat. To uděláte tak, že vypočítáte, kolik bitů, nBits, potřebujeme k vyjádření celých čísel až do hodnoty 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 bezpečné heslo.

K reprezentaci čísla mezi 0 a 12 potřebujete ${\lfloor ln(12) / ln(2) + 1 \rfloor}$ nebo 4 bity. (Postup odvození této rovnice v zájmu zrychlení vynecháme.)

Ř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í číslo 6 jako heslo. V praxi nastavte jako maximum větší číslo, protože nižší čísla se snadno prolomí pouhým vyzkoušením všech možných hesel. Ve skutečnosti, pokud chcete zvýšit složitost hádání nebo prolomení hesla, můžete použít kód ASCII k převodu binárního souboru na text a vygenerování hesla pomocí čísel, symbolů a smíšených písmen.

Zápis generátoru náhodných bitů

Prvním krokem je napsání Q# operace, která generuje náhodný bit. Tato operace bude jedním ze 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 qubit přidělený, je vždy ve stavu .Zero
• Operaci použijete H k umístění qubitu do stejné superpozice.
• Operaci použijete M k měření qubitu, vrácení naměřené hodnoty (Zero nebo One).
• Operaci použijete Reset k resetování qubitu do stavu |0〉.

Když qubit umístíte do superpozice s H operací a změříte ho M pomocí operace, výsledkem bude při každém vyvolání kódu jiná hodnota.

Q# Vizualizace kódu pomocí Blochova koule

Severní pól na Blochově kouli představuje 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 poskytnutí hodnoty 0 , 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 qubit změřte 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 a vytvořit tak celá čísla. Pokud například zavoláte operaci třikrát, abyste získali tři náhodné bity, můžete vytvořit náhodná 3bitová čísla (to znamená náhodné číslo mezi 0 a 7).

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

1. Nejprve musíte do programu přidat požadované Q# obory názvů. Pro kompletní generátor náhodných čísel musíte zahrnout tři Q# obory názvů: Microsoft.Quantum.Math, Microsoft.Quantum.Intrinsica Microsoft.Quantum.Convert.

   open Microsoft.Quantum.Convert;
   open Microsoft.Quantum.Intrinsic;
   open Microsoft.Quantum.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 {
               set 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.

   • Musíte vypočítat počet bitů potřebných k vyjádření celých čísel až do maxhodnoty . Funkce BitSizeI z Microsoft.Quantum.Math oboru názvů převede celé číslo na počet bitů potřebných k jeho vyjádření.
   • 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 úplně stejně jako smyčka for v jiných programovacích jazycích.
   • Proměnná bits je měnitelná 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 pochází z Microsoft.Quantum.Convert oboru názvů . Tato funkce převede bitový řetězec na kladné celé číslo.

3. Nakonec přidáte vstupní bod. V tomto příkladu Main je operace vstupním bodem programu. Volá operaci, GenerateRandomNumberInRange která vygeneruje náhodné číslo mezi 0 a 100.

       @EntryPoint()
       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í. Zde definujeme maximální hodnotu jako 100.

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

namespace QuantumRandomNumberGenerator {
    open Microsoft.Quantum.Convert;
    open Microsoft.Quantum.Intrinsic;
    open Microsoft.Quantum.Math;

    @EntryPoint()
    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 {
            set 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 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;
    }
}

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 v Pythonu.

Copilot v Azure Quantum

Svůj Q# kód můžete bezplatně otestovat pomocí copilotu v Azure Quantum – potřebujete jen e-mailový účet Microsoft (MSA). Další informace o funkci Copilot ve službě Azure Quantum najdete v tématu Prozkoumání Azure Quantum.

1. Otevřete copilot v Azure Quantum v prohlížeči.

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

   namespace Tutorial {
       open Microsoft.Quantum.Convert;
       open Microsoft.Quantum.Intrinsic;
       open Microsoft.Quantum.Math;
   
       @EntryPoint()
       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 {
               set 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é se mají spustit, a klikněte na Spustit.

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

5. Kliknutím na Vysvětlit kód zobrazíte výzvu Copilotu, aby vám kód vysvětlil.

Tip

V nástroji Copilot v Azure Quantum můžete svůj program otevřít v editoru VS Code pro web kliknutím na tlačítko s logem VS Code v pravém rohu editoru kódu.

Q# program v editoru Visual Studio Code

1. Otevřete Visual Studio Code a vyberte Soubor > 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 souboru následující kód RandomNumberGenerator.qs .

   namespace Tutorial {
       open Microsoft.Quantum.Convert;
       open Microsoft.Quantum.Intrinsic;
       open Microsoft.Quantum.Math;
   
       @EntryPoint()
       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 {
               set 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. Před spuštěním programu musíte nastavit target profil na Hodnotu Neomezený. Vyberte Zobrazit –> Paleta příkazů, vyhledejte QIR, vyberte Q#: Nastavte profil Azure Quantum QIR targeta pak vyberte Q#: neomezené.

5. Pokud chcete program spustit, vyberte Spustit Q# soubor z rozevíracího seznamu ikony přehrávání v pravém horním rohu nebo stiskněte Kombinaci kláves Ctrl+F5. Program spustí operaci nebo funkci označenou atributem @EntryPoint() ve výchozím simulátoru.

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

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

Poznámka

target Pokud profil není nastavený na hodnotu Unrestricted, zobrazí se při spuštění programu chyba.

Vykreslení histogramu frekvence

Pojďme si vizualizovat rozdělení výsledků získaných spuštěním kvantového programu několikrát. Histogram frekvence pomáhá vizualizovat rozdělení pravděpodobnosti těchto výsledků.

1. Vyberte Zobrazit –> Paleta příkazů nebo stiskněte Kombinaci kláves Ctrl+Shift+P a zadejte histogram, který by měl zobrazit Q#soubor : Spustit a zobrazit možnost histogramu . Tuto možnost vyberte, Q# pokud chcete otevřít okno histogramu.

2. Zadejte několik snímků , které se mají spustit, 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 pozorování výsledku. Počet různých výsledků se může při každém spuštění histogramu lišit.

   

   Tip

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

4. Kliknutím na pruh zobrazíte procento tohoto výsledku.

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

   

Jupyter Notebook ve VS Code

1. Ve VS Code vyberte Zobrazit > paletu příkazů a vyberte Vytvořit: Nový Jupyter Notebook.

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

   import qsharp
   

3. Přidejte program kvantového generátoru náhodných čísel. Provedete to pomocí %%qhsarp příkazu magic. Zkopírujte tento kód do druhé buňky.

   %%qsharp
   
   open Microsoft.Quantum.Convert;
   open Microsoft.Quantum.Intrinsic;
   open Microsoft.Quantum.Math;
   
   @EntryPoint()
   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 {
           set 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 kód spusťte. Stejnou simulaci můžete spustit několikrát nezávisle na sobě. 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.

Další kroky

Projděte si další Q# kurzy:

• Kvantové provázání ukazuje, jak napsat Q# program, který manipuluje s qubity a měří je a demonstruje úč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í najednou.