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 membangun generator bilangan acak kuantum.

Kiat

Jika Anda ingin mempercepat perjalanan komputasi kuantum Anda, lihat Kode dengan Microsoft Quantum, fitur unik dari situs web Microsoft 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 Copilot tentang komputasi kuantum.

Prasyarat

Untuk menjalankan sampel kode di Copilot di Microsoft Quantum, Anda harus memiliki akun email Microsoft (MSA).

Untuk mengembangkan dan menjalankan sampel kode di Visual Studio Code (VS Code) dan Jupyter Notebook, instal yang berikut ini:

• Versi terbaru VS Code atau buka VS Code for the Web.

• Versi terbaru ekstensi (QDK)Microsoft Quantum Development Kit. Untuk detail penginstalan, lihat Menyiapkan ekstensi QDK.

• Ekstensi Python dan Jupyter untuk Visual Studio Code.

• Pustaka Python terbaru qdk dengan jupyter tambahan. Untuk menginstal ini, buka terminal dan jalankan perintah berikut:

  pip install --upgrade "qdk[jupyter]"
  

Tentukan masalah

Komputer klasik tidak menghasilkan angka acak, melainkan nomor pseudorandom. Generator bilangan pseudorandom menghasilkan urutan angka deterministik berdasarkan nilai awal, yang disebut benih. 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 dapat berada dalam status 0 atau dalam status 1. Namun, sebelum pengukuran, status qubit mewakili probabilitas membaca 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 bit ini menjadi rangkaian bit, Anda dapat membentuk angka yang lebih besar. Dalam contoh ini, urutan bit ${0110}$ setara dengan enam dalam desimal.

$${0110_{\ biner} \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 uraikan apa logika seharusnya untuk generator angka acak.

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.

Tulis 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 kutub, semakin tinggi peluang qubit runtuh menjadi nilai klasik yang ditetapkan ke kutub itu ketika diukur. Misalnya, status qubit yang diwakili oleh panah dalam gambar berikut memiliki probabilitas yang 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 yang acak dan probabilitas pengukuran 0 dan 1 sama, Anda telah mendapatkan sebuah bit yang sepenuhnya 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 membangun 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: Std.Mathdan Std.Convert.

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

2. Selanjutnya, Anda menentukan operasi GenerateRandomNumberInRange. 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 {
           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 Std.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 Std.Convert , mengonversi string bit menjadi bilangan bulat positif.

3. Terakhir, Anda menambahkan titik masuk ke program. Secara bawaan, pengkompilasi Q# mencari operasi Main dan mulai pemrosesan 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 Main, lihat Poin Masuk.

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

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

Menjalankan program generator angka acak

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

Copilot di Microsoft Quantum

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

1. Buka Copilot di Microsoft Quantum di browser Anda.

2. Salin dan tempel kode berikut ke editor kode.

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

Kiat

Dari Copilot di Microsoft Quantum, Anda dapat membuka program Anda di VS Code untuk Web dengan memilih tombol logo VS Code di sudut kanan atas editor kode.

Q# program di Visual Studio Code

1. Di Visual Studio Code, buka menu File 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 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. Untuk menjalankan program Anda, pilih Jalankan dari daftar perintah sebelumnya Main(), atau tekan Ctrl + F5. Program menjalankan Main() operasi pada simulator default.

   

5. Output Anda akan muncul di konsol debug.

6. Jalankan program lagi untuk melihat hasil yang berbeda.

Catatan

Jika profil QIR target tidak diatur ke Tidak Dibatasi, maka Anda mendapatkan kesalahan saat menjalankan program. Untuk program ini, pengkompilasi secara otomatis mengatur target profil ke Tidak Dibatasi kecuali Anda mengatur profil sendiri.

Plot frekuensi histogram

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 QDK: Jalankan file dan tampilkan perintah 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.

   

   Kiat

   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 View > palette perintah dan pilih Buat: Notebook Jupyter Baru.

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

   from qdk 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 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. Terakhir, jalankan kode. Anda dapat menjalankan simulasi yang sama beberapa kali, secara independen. Setiap simulasi independen disebut "sesi". 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:

• Keterjeratan kuantum menunjukkan cara menulis Q# program yang memanipulasi dan mengukur qubit serta menjelaskan efek dari superposisi dan keterjeratan.
• 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.