Tutorial: Menerapkan generator bilangan acak kuantum di Q#

Dalam tutorial ini, Anda belajar menulis program kuantum dasar yang Q# memanfaatkan sifat mekanika kuantum untuk menghasilkan angka acak.

Dalam tutorial ini, Anda akan:

• Buat Q# program.
• Tinjau komponen Q# utama program.
• Tentukan logika masalah.
• Gabungkan operasi klasik dan kuantum untuk menyelesaikan masalah.
• Bekerja dengan qubit dan superposisi untuk mem-build generator bilangan acak kuantum.

Tip

Jika Anda ingin mempercepat perjalanan komputasi kuantum Anda, lihat Kode dengan Azure Quantum, fitur unik dari situs web Azure Quantum. Di sini, Anda dapat menjalankan sampel bawaan Q# atau program Anda sendiri Q# , menghasilkan kode baru Q# dari perintah Anda, membuka dan menjalankan kode Anda di Visual Studio Code untuk Web dengan satu klik, dan mengajukan pertanyaan apa pun tentang komputasi kuantum.

Prasyarat

• Untuk menjalankan sampel kode di Copilot di Azure Quantum:

  • Akun email Microsoft (MSA).

• Untuk mengembangkan dan menjalankan sampel kode di Visual Studio Code:

  • Versi terbaru Visual Studio Code atau buka VISUAL Code di Web.

  • Versi terbaru ekstensi AzureQuantum Development Kit. Untuk detail penginstalan, lihat Menginstal QDK di Visual Studio Code.

  • Jika Anda ingin menggunakan Jupyter Notebooks, Anda juga perlu menginstal ekstensi Python, dan Jupyter , dan paket Python terbaru qsharp . Untuk melakukannya, buka terminal dan jalankan perintah berikut:

    $ pip install --upgrade  qsharp
    

Tentukan masalah

Komputer klasik tidak menghasilkan angka acak, melainkan nomor pseudorandom. Generator angka pseudorandom menghasilkan urutan angka deterministik berdasarkan beberapa nilai awal, yang disebut seed. Untuk memperkirakan nilai acak dengan lebih baik, seed ini sering kali merupakan waktu saat ini dari jam CPU.

Komputer kuantum, di sisi lain, dapat menghasilkan angka yang benar-benar acak. Ini karena pengukuran qubit dalam superposisi adalah proses probabilistik. Hasil pengukuran acak, dan tidak ada cara untuk memprediksi hasilnya. Ini adalah prinsip dasar generator angka acak kuantum.

Qubit adalah unit informasi kuantum yang dapat berada dalam superposisi. Ketika diukur, qubit hanya bisa dalam status 0 atau dalam status 1. Namun, sebelum pengukuran, status qubit mewakili peluang membaca baik 0 atau 1 dengan pengukuran.

Anda mulai dengan mengambil qubit dalam status dasar, misalnya nol. Langkah pertama generator angka acak adalah menggunakan operasi Hadamard untuk menempatkan qubit ke dalam superposisi yang sama. Pengukuran status ini menghasilkan nol atau satu dengan probabilitas 50% dari setiap hasil, bit yang benar-benar acak.

Tidak ada cara untuk mengetahui apa yang akan Anda dapatkan setelah pengukuran qubit dalam superposisi, dan hasilnya adalah nilai yang berbeda setiap kali kode dipanggil. Tetapi bagaimana Anda dapat menggunakan perilaku ini untuk menghasilkan angka acak yang lebih besar?

Katakanlah Anda mengulangi proses empat kali, menghasilkan urutan digit biner ini:

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

Jika Anda menggabungkan, atau menggabungkan, bit ini menjadi string bit, Anda dapat membentuk angka yang lebih besar. Dalam contoh ini, urutan bit ${0110}$ setara dengan enam dalam desimal.

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

Jika Anda mengulangi proses ini berkali-kali, Anda dapat menggabungkan beberapa bit untuk membentuk angka besar apa pun. Dengan menggunakan metode ini, Anda dapat membuat angka untuk digunakan sebagai kata sandi yang aman, karena Anda dapat yakin bahwa tidak ada peretas yang dapat menentukan hasil urutan pengukuran.

Menentukan logika generator angka acak

Mari kita garis besarkan apa logika generator angka acak harus:

1. Tentukan max sebagai angka maksimum yang ingin Anda hasilkan.
2. Tentukan jumlah bit acak yang perlu Anda hasilkan. Ini dilakukan dengan menghitung berapa banyak bit, nBits, Anda perlu mengekspresikan bilangan bulat hingga max.
3. Hasilkan string bit acak yang panjangnya nBits.
4. Jika string bit mewakili angka yang lebih besar dari max, kembali ke langkah ketiga.
5. Jika tidak, prosesnya selesai. Kembalikan angka yang dihasilkan sebagai bilangan bulat.

Sebagai contoh, mari kita atur max ke 12. Artinya, 12 adalah angka terbesar yang ingin Anda gunakan sebagai kata sandi.

Anda memerlukan ${\lfloor ln(12) / ln(2) + 1 \rfloor}$, atau 4 bit untuk mewakili angka antara 0 dan 12. Kita dapat menggunakan fungsi BitSizeIbawaan , yang mengambil bilangan bulat apa pun dan mengembalikan jumlah bit yang diperlukan untuk mewakilinya.

Katakanlah Anda menghasilkan string bit ${1101_{\ binary}}$, yang setara dengan ${13_{\ decimal}}$. Karena 13 lebih besar dari 12, Anda mengulangi prosesnya.

Berikutnya, Anda menghasilkan string bit ${0110_{\ binary}}$, yang setara dengan ${6_{\ decimal}}$. Karena 6 kurang dari 12, proses selesai.

Generator angka acak kuantum akan mengembalikan nomor 6 sebagai kata sandi Anda. Dalam praktiknya, atur angka yang lebih besar sebagai maksimum karena angka yang lebih rendah mudah dibobol hanya dengan mencoba semua kata sandi yang mungkin. Bahkan, untuk meningkatkan kesulitan menebak atau membobol kata sandi, Anda dapat menggunakan kode ASCII untuk mengonversi biner ke teks dan untuk menghasilkan kata sandi dengan menggunakan angka, simbol, dan campuran huruf besar-kecil.

Menulis generator bit acak

Langkah pertama adalah menulis Q# operasi yang menghasilkan bit acak. Operasi ini akan menjadi salah satu blok penyusun generator angka acak.

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

Sekarang lihat kode baru.

• Anda menentukan GenerateRandomBit operasi, yang tidak mengambil input dan menghasilkan nilai jenis Result. Jenis ini Result mewakili hasil pengukuran dan dapat memiliki dua nilai yang mungkin: Zero atau One.
• Anda mengalokasikan satu qubit dengan use kata kunci. Saat dialokasikan, qubit selalu dalam status |0〉.
• Anda menggunakan H operasi untuk menempatkan qubit dalam superposisi yang sama.
• Anda menggunakan M operasi untuk mengukur qubit, mengembalikan nilai terukur (Zero atau One).
• Anda menggunakan Reset operasi untuk mereset kubit ke status |0〉.

Dengan menempatkan qubit dalam superposisi dengan H operasi dan mengukurnya dengan M operasi, hasilnya adalah nilai yang berbeda setiap kali kode dipanggil.

Memvisualisasikan Q# kode dengan bola Bloch

Dalam bola Bloch, kutub utara mewakili nilai klasik 0 dan kutub selatan mewakili nilai klasik 1. Setiap superposisi dapat diwakili oleh titik pada bola (diwakili oleh panah). Semakin dekat ujung panah ke tiang, semakin tinggi peluang qubit ciut ke dalam nilai klasik yang ditetapkan ke kutub itu ketika diukur. Misalnya, status qubit yang diwakili oleh panah pada gambar berikut memiliki peluang lebih tinggi untuk memberikan nilai 0 jika Anda mengukurnya.

Anda dapat menggunakan representasi ini untuk memvisualisasikan apa yang dilakukan kode:

1. Pertama, mulailah dengan qubit yang diinisialisasi dalam status |0〉 dan terapkan H operasi untuk membuat superposisi yang sama di mana probabilitas untuk 0 dan 1 sama.

   

2. Kemudian ukur qubit dan simpan outputnya:

   

Karena hasil pengukuran acak dan peluang mengukur 0 dan 1 adalah sama, Anda telah memperoleh bit yang benar-benar acak. Anda dapat memanggil operasi ini beberapa kali untuk membuat bilangan bulat. Misalnya, jika Anda memanggil operasi tiga kali untuk mendapatkan tiga bit acak, Anda dapat mem-build angka 3-bit acak (yaitu, angka acak antara 0 dan 7).

Menulis generator angka acak lengkap

1. Pertama, Anda perlu mengimpor namespace yang diperlukan dari Q# pustaka standar ke program. Pengkompilasi Q# memuat banyak fungsi dan operasi umum secara otomatis, namun untuk generator angka acak lengkap, Anda memerlukan beberapa fungsi dan operasi tambahan dari dua Q# namespace: Microsoft.Quantum.Mathdan Microsoft.Quantum.Convert.

   import Microsoft.Quantum.Convert.*;
   import Microsoft.Quantum.Math.*;
   

2. Selanjutnya, Anda menentukan GenerateRandomNumberInRange operasi. Operasi ini berulang kali memanggil operasi GenerateRandomBit untuk membangun string 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;
   }
   
   

   Sekarang luangkan waktu sejenak untuk meninjau kode baru.

   • Anda perlu menghitung jumlah bit yang diperlukan untuk mengekspresikan bilangan bulat hingga max. Fungsi BitSizeI dari Microsoft.Quantum.Math namespace mengonversi bilangan bulat ke jumlah bit yang diperlukan untuk mewakilinya.
   • Operasi SampleRandomNumberInRange menggunakan for perulangan untuk menghasilkan angka acak sampai menghasilkan satu yang sama dengan atau kurang dari max. Perulangan for bekerja sama persis dengan perulangan for dalam bahasa pemrograman lainnya.
   • Variabel bits adalah variabel yang dapat diubah. Variabel yang dapat berubah adalah variabel yang dapat berubah selama perhitungan. Anda menggunakan arahan set untuk mengubah nilai variabel yang dapat berubah.
   • Fungsi, ResultArrayAsInt dari namespace default Microsoft.Quantum.Convert , mengonversi string bit menjadi bilangan bulat positif.

3. Terakhir, Anda menambahkan titik masuk ke program. Secara default, pengkompilasi Q# mencari Main operasi dan mulai memproses di sana. Ini memanggil GenerateRandomNumberInRange operasi untuk menghasilkan angka acak antara 0 dan 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);
   }
   

   Arahan let mendeklarasikan variabel yang tidak berubah selama komputasi. Di sini Anda menentukan nilai maksimum sebagai 100.

   Untuk informasi selengkapnya tentang operasi ini Main , lihat Titik Masuk.

4. Kode lengkap untuk generator angka acak adalah sebagai berikut:

import Microsoft.Quantum.Convert.*;
import Microsoft.Quantum.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 {
        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 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;
}

Menjalankan program generator angka acak

Anda dapat menjalankan program di Copilot di Azure Quantum, dan di Visual Studio Code sebagai aplikasi mandiri Q# atau menggunakan program host Python.

Copilot di Azure Quantum

Anda dapat menguji kode Anda Q# dengan Copilot di Azure Quantum gratis - yang Anda butuhkan adalah akun email Microsoft (MSA). Untuk informasi selengkapnya tentang Copilot di Azure Quantum, lihat Menjelajahi Azure Quantum.

1. Buka Copilot di Azure Quantum di browser Anda.

2. Salin dan tempel kode berikut ke editor kode.

   import Microsoft.Quantum.Convert.*;
   import Microsoft.Quantum.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 {
           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. Pilih jumlah bidikan yang akan dijalankan, dan pilih Jalankan.

4. Hasilnya ditampilkan dalam histogram dan di bidang Hasil .

5. Pilih Jelaskan kode untuk meminta Copilot untuk menjelaskan kode kepada Anda.

Tip

Dari Copilot di Azure Quantum, Anda dapat membuka program Anda di Visual Studio Code untuk Web dengan memilih tombol logo VISUAL Code di sudut kanan editor kode.

Q# program di Visual Studio Code

1. Buka Visual Studio Code dan pilih File > Teks Baru untuk membuat file baru.

2. Simpan file sebagai RandomNumberGenerator.qs. File ini akan berisi Q# kode untuk program Anda.

3. Salin kode berikut dalam RandomNumberGenerator.qs file.

   
   import Microsoft.Quantum.Convert.*;
   import Microsoft.Quantum.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 {
           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. Sebelum menjalankan program, Anda perlu mengatur profil ke target Tidak Dibatasi. Pilih Tampilkan -> Palet Perintah, cari QIR, pilihQ# : Atur profil QIR target Azure Quantum, lalu pilih Q#: tidak dibatasi.

5. Untuk menjalankan program Anda, pilih Jalankan Q# File dari menu drop-down ikon putar di kanan atas, pilih Jalankan dari daftar perintah sebelumnya Main(), atau tekan Ctrl+F5. Program menjalankan Main() operasi pada simulator default.

   

6. Output Anda akan muncul di konsol debug.

7. Jalankan program lagi untuk melihat hasil yang berbeda.

Catatan

target Jika profil tidak diatur ke Tidak Dibatasi, Anda akan mendapatkan kesalahan saat menjalankan program.

Plot histogram frekuensi

Mari kita visualisasikan distribusi hasil yang diperoleh dari menjalankan program kuantum beberapa kali. Histogram frekuensi membantu memvisualisasikan distribusi probabilitas hasil ini.

1. Pilih Lihat -> Palet Perintah dan ketik "histogram" yang memunculkan Q#opsi : Jalankan file dan tampilkan histogram . Anda juga dapat memilih Histogram dari daftar perintah sebelumnya Main(). Pilih opsi ini untuk membuka jendela Q# histogram.

   

2. Masukkan sejumlah bidikan untuk menjalankan program, misalnya, 100 bidikan, dan tekan Enter. Histogram akan ditampilkan di Q# jendela histogram.

3. Setiap bilah dalam histogram sesuai dengan kemungkinan hasil, dan tingginya mewakili berapa kali hasil tersebut diamati. Jumlah hasil yang berbeda mungkin berbeda setiap kali Anda menjalankan histogram.

   

   Tip

   Anda dapat memperbesar histogram menggunakan roda gulir mouse atau gerakan trackpad. Saat diperbesar, Anda dapat menggeser bagan dengan menekan 'Alt' saat menggulir.

4. Pilih bilah untuk menampilkan persentase hasil tersebut.

5. Pilih ikon pengaturan kiri atas untuk menampilkan opsi. Anda dapat menampilkan 10 hasil teratas, 25 hasil teratas, atau semua hasil. Anda juga dapat mengurutkan hasil dari tinggi ke rendah, atau rendah ke tinggi.

   

Jupyter Notebook di Visual Studio Code

1. Di Visual Studio Code, pilih Tampilkan Palet Perintah dan pilih Buat: Notebook Jupyter > Baru.

2. Di sel pertama, impor qsharp paket dalam kode Python Anda:

   import qsharp
   

3. Q# Tambahkan kode untuk program generator angka acak kuantum. Untuk melakukannya, Anda menggunakan %%qsharp perintah ajaib. Perhatikan bahwa perintah mengubah %%qsharp sel buku catatan dari tipe Python menjadi tipe Q#. Salin kode ini ke sel kedua.

   %%qsharp
   
   import Microsoft.Quantum.Convert.*;
   import Microsoft.Quantum.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 {
           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. Terakhir, jalankan kode. Anda dapat menjalankan simulasi yang sama beberapa kali, secara independen. Setiap simulasi independen disebut "bidikan". Misalnya, mari kita jalankan simulasi, 100 kali.

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

Catatan

Cuplikan kode ini saat ini tidak berjalan pada perangkat keras targetsAzure Quantum yang tersedia, karena yang dapat ResultArrayAsInt dipanggil memerlukan QPU dengan profil komputasi penuh.

Konten terkait

Jelajahi tutorial Q# lainnya:

• Entanglemen kuantum menunjukkan cara menulis Q# program yang memanipulasi dan mengukur qubit dan menunjukkan efek superposisi dan entanglemen.
• Algoritma pencarian Grover menunjukkan cara menulis Q# program yang menggunakan algoritma pencarian Grover.
• Quantum Fourier Transforms mengeksplorasi cara menulis Q# program yang secara langsung membahas qubit tertentu.
• Quantum Katas adalah tutorial dan latihan pemrograman mandiri yang bertujuan untuk mengajarkan elemen komputasi dan Q# pemrograman kuantum secara bersamaan.