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

Poznámka

Po 30. červnu 2024 už nebude podporována sada Microsoft Quantum Development Kit (Classic QDK). Pokud jste stávající vývojář QDK, doporučujeme přejít na novou verzi Azure Quantum Development Kit (moderní QDK), abyste mohli 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 psát základní kvantový program, Q# který využívá povahu kvantové mechaniky k vytvoření náhodného čísla.

V tomto kurzu:

• Q# Create programu.
• Zkontrolujte hlavní součásti Q# programu.
• Definujte logiku problému.
• Pokud chcete problém vyřešit, zkombinujte klasické a kvantové operace.
• 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ód s využitím Azure Quantum, jedinečné funkce webu Azure Quantum. Tady můžete spustit předdefinované Q# ukázky nebo vlastní Q# programy, vygenerovat nový Q# kód z výzev, otevřít a spustit kód v editoru VS Code pro web jedním kliknutím a zeptat se společnosti Copilot na jakékoli otázky týkající se kvantových výpočtů.

Požadavky

• Spuštění ukázky kódu v copilotu v 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 rozšíření Pythonu a Jupyteru 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 spíše pseudonáhodná čísla. Generátor pseudonáhodných čísel vygeneruje deterministickou posloupnost čísel na základě 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 předpovědět výsledek. 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 pouze ve stavu 0 nebo 1 . Před měřením však stav qubitu představuje pravděpodobnost čtení hodnoty 0 nebo 1 s měřením.

Začnete tím, že qubit vezmete v základním stavu, například nula. Prvním krokem generátoru náhodných čísel je použití hadamardové operace k uvedení 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ýsledkem je při každém vyvolání kódu jiná hodnota. 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 tak libovolné velké číslo. Teď můžete svému nadřízenému poskytnout toto číslo jako bezpečné heslo, protože si můžete být jistí, že žádný prostorový hacker 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 za předpokladu, že 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 zabezpečené heslo.

Potřebujete ${\lfloor ln(12) / ln(2) + 1 \rfloor}$ nebo 4 bity, které představují číslo mezi 0 a 12. (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í tím, že vyzkoušíte všechna možná hesla. Ve skutečnosti, pokud chcete zvýšit obtížnost uhodnutí nebo prolomení hesla, můžete použít kód ASCII k převodu binárního souboru na text a k vygenerování hesla pomocí čísel, symbolů a písmen s různými písmeny.

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

Prvním krokem je napsání Q# operace, která vygeneruje 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ž se qubit přidělí, je vždy ve Zero stavu.
• Operaci použijete H k umístění qubitu do stejné superpozice.
• M Pomocí operace změříte qubit a vrátíte naměřenou hodnotu (Zero nebo One).
• Pomocí Reset operace resetujete qubit do stavu |0〉.

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

Q# Vizualizace kódu pomocí Blochové 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, že hodnotu 0 změříte.

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

1. Nejprve začněte qubitem inicializovaným ve stavu 0 a pomocí H operace vytvořte stejnou superpozici, ve které jsou pravděpodobnosti pro 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 a vytvořit tak celá čísla. Pokud například třikrát zavoláte operaci, 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 úplné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 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 úplně 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 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í. Tady definujeme maximální hodnotu jako 100.

4. Úplný 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 ve službě Copilot 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 kód můžete bezplatně otestovat Q# pomocí Copilotu v Azure Quantum – potřebujete jen e-mailový účet Microsoft (MSA). Další informace o funkci Copilot v Azure Quantum najdete v tématu Prozkoumání Azure Quantum.

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

2. Zkopírujte a vložte následující kód 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é chcete 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 aplikaci 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 RandomNumberGenerator.qs souboru následující kód.

   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 je nutné nastavit target profil na hodnotu Unrestricted. 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 v rozevíracím 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 Zobrazení –> 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, pokud chcete otevřít okno histogramu Q# .

2. Zadejte několik 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 výskytů 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 posouvat graf 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 prvních 10 výsledků, prvních 25 výsledků nebo všechny výsledky. Můžete také seřadit výsledky od nejvyšších po nejnižší nebo od nejnižších po vysoké.

   

Jupyter Notebook ve VS Code

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

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

   import qsharp
   

3. Q# Přidejte kód pro kvantový generátor náhodných čísel. Uděláte to tak, že použijete %%qhsarp příkaz magic. Všimněte si %%qsharp , že 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
   
   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". Například spustíme simulaci 100krát.

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

Poznámka

Tento fragment kódu se v současné době 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

Prozkoumejte 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í s vlastním tempem zaměřené na výuku prvků kvantového computingu a Q# programování současně.