Latihan - Membuat status superposisi yang berbeda dengan Q#

  • 12 menit

Di unit sebelumnya, Anda belajar tentang superposisi dan notasi Dirac. Itu teori yang cukup untuk saat ini! Mari kita tulis beberapa kode untuk menjelajahi superposisi di Q#.

Dalam unit ini, Anda membuat status superposisi kuantum di Q# dan menjelajahi peran probabilitas dalam hasil pengukuran. Anda juga menggunakan DumpMachine fungsi di Q# untuk memeriksa bagaimana status sistem berubah selama komputasi kuantum.

Membuat file Q# baru

  1. Buka Visual Studio Code (VS Code).
  2. Buka menu File , lalu pilih File Teks Baru untuk membuat file baru.
  3. Simpan file sebagai Main.qs.

Mulai menggunakan superposisi

Mari kita mulai dengan program Q# sederhana yang menggunakan qubit dalam status superposisi untuk menghasilkan nilai bit acak, 0 atau 1. Dalam kode kami, kita menggunakan DumpMachine fungsi untuk melihat status qubit di titik yang berbeda dalam program.

  1. Salin dan tempel kode berikut ke dalam file Main.qs :

    import Std.Diagnostics.*;

operation Main() : Result {
    use q = Qubit();
    Message("Initialized qubit:");
    DumpMachine(); // First dump
    Message(" ");
    H(q);
    Message("Qubit after applying H:");
    DumpMachine(); // Second dump
    Message(" ");
    let randomBit = M(q);
    Message("Qubit after the measurement:");
    DumpMachine(); // Third dump
    Message(" ");
    Reset(q);
    Message("Qubit after resetting:");
    DumpMachine(); // Fourth dump
    Message(" ");
    return randomBit;
}

  2. Untuk menjalankan program Anda pada simulator bawaan, pilih jendela Jalankan kode di atas Main operasi atau tekan Ctrl + F5. Output Anda muncul di konsol debug.

  3. Periksa konsol debug untuk menemukan hasil pengukuran Anda, baik Zero atau One.

Fungsi ini DumpMachine membuat tabel informasi yang menjelaskan status sistem kuantum, yang dalam hal ini adalah satu qubit. Informasi dari DumpMachine mencakup amplitudo probabilitas, probabilitas pengukuran, dan fase dalam radian untuk setiap status dasar.

Kode Anda memanggil DumpMachine fungsi empat kali:

  • Setelah Anda mengalokasikan qubit
  • Setelah Anda menempatkan qubit ke dalam status superposisi
  • Setelah Anda mengukur status qubit
  • Setelah Anda mengatur ulang qubit

Mari kita periksa output dari setiap panggilan ke DumpMachine:

  • Kubit yang diinisialisasi: Saat Anda mengalokasikan qubit dengan perintah use, qubit selalu dimulai dalam keadaan $|0\rangle$.

    Initialized qubit:

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
   |0⟩ |  1.0000+0.0000𝑖 |   100.0000% |   0.0000

  • Qubit setelah menerapkan H: Setelah Anda menerapkan H operasi, qubit berada dalam status superposisi yang setara, $|\psi\rangle=\frac1{\sqrt2} |0\rangle + \frac1{\sqrt2} |1\rangle$.

    Qubit after applying H:

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
   |0⟩ |  0.7071+0.0000𝑖 |    50.0000% |   0.0000
   |1⟩ |  0.7071+0.0000𝑖 |    50.0000% |   0.0000

  • Qubit setelah pengukuran: Setelah Anda mengukur qubit, hasilnya adalah Zero atau One, dan qubit sepenuhnya dalam keadaan yang Anda ukur.

    Qubit after the measurement:

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
   |1⟩ |  1.0000+0.0000𝑖 |   100.0000% |   0.0000

    Catatan

    Output Anda dari DumpMachine setelah pengukuran mungkin berbeda dari contoh output karena Anda memiliki 50% kesempatan untuk mengukur setiap status. Probabilitas hasilnya deterministik, tetapi hasil pengukuran individu tidak.

  • Qubit setelah mengatur ulang: Operasi Reset mereset qubit ke status $|0\rangle$ sehingga dapat digunakan lagi untuk komputasi di masa mendatang.

    Qubit after resetting:

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
   |0⟩ |  1.0000+0.0000𝑖 |   100.0000% |   0.0000

Menjelajahi status superposisi lainnya

Sekarang setelah Anda tahu cara memeriksa status sistem qubit dengan DumpMachine, mari kita jelajahi operasi lain yang menempatkan sistem ke berbagai jenis status superposisi.

Generator bit acak saat ini menghasilkan atau ZeroOne dengan probabilitas 50%. Dalam contoh berikutnya, probabilitasnya tidak sama.

Generator bit acak tidak merata

Misalkan Anda ingin membuat generator bit acak yang tidak seimbang, yang berarti bahwa kemungkinan mendapatkan Zero berbeda dari kemungkinan mendapatkan One.

Misalnya, Anda menginginkan hasilnya Zero dengan probabilitas $P$ dan hasilnya One dengan probabilitas $1 - P$. Berikut adalah status qubit valid yang menghasilkan generator bit acak seperti itu:

$$|\psi\rangle=\sqrt{P}|0\rangle+\sqrt{1 - P}|1\rangle$$

Untuk status ini $|\psi\rangle$, $\alpha=\sqrt{P}$ dan $\beta=\sqrt{1 - P}$ adalah amplitude probabilitas dari status dasar $|0\rangle$ dan $|1\rangle$, masing-masing.

Untuk mendapatkan status ini, Anda dapat menerapkan operator secara berurutan $R_y(2\cos^{-1}\sqrt{P})$ ke qubit yang dimulai dalam status $|0\rangle$. Untuk mencapai hasil ini dalam Q#, gunakan Ry dari pustaka standar.

Kiat

Untuk mempelajari lebih lanjut tentang matematika di balik operasi qubit tunggal, lihat tutorial Gerbang Qubit Tunggal di Quantum Katas.

Untuk membuat status superposisi condong di Q#, ikuti langkah-langkah berikut:

  1. Ganti semua kode di Main.qs dengan contoh berikut, lalu simpan file. Contoh ini memilih $\alpha$ menjadi sekitar $\frac13$.

    import Std.Diagnostics.*;
import Std.Math.*;

operation Main() : Result {
    use q = Qubit();
    let P = 0.333333; // P is 1/3
    Ry(2.0 * ArcCos(Sqrt(P)), q);
    Message("The qubit is in the desired state.");
    DumpMachine(); // Dump the state of the qubit 
    Message("Your skewed random bit is:");
    let skewedrandomBit = M(q);
    Reset(q);
    return skewedrandomBit;
}

  2. Untuk menjalankan program Anda di dalam simulator bawaan, pilih opsi Jalankan di atas operasi Main atau tekan tombol Ctrl + F5. Output Anda muncul di konsol debug.

  3. Periksa output dari DumpMachine dan hasil pengukuran Anda. Misalnya, outputnya mirip dengan yang berikut ini:

    The qubit is in the desired state.

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
   |0⟩ |  0.5773+0.0000𝑖 |    33.3333% |   0.0000
   |1⟩ |  0.8165+0.0000𝑖 |    66.6667% |   0.0000

Your skewed random bit is:

One

Perhatikan bahwa probabilitas Zero hasil pengukuran adalah sekitar 33,33% dan probabilitas One hasilnya adalah sekitar 66,67%. Generator bit acak ini condong ke arah One.

Catatan

Output dari hasil pengukuran Anda mungkin berbeda dari output contoh karena generator acak bit bersifat probabilistik. Probabilitas hasilnya deterministik, tetapi hasil pengukuran individu tidak.

Superposisi multi-qubit

Sejauh ini, kami hanya mempertimbangkan sistem qubit tunggal. Tetapi komputer kuantum yang baik membutuhkan banyak qubit untuk melakukan perhitungan yang berguna. Bagaimana cara kerja status kuantum dan superposisi ketika sistem kita memiliki lebih dari satu qubit?

Sebagai contoh, pertimbangkan sistem tiga qubit. Setiap qubit dapat memiliki nilai 0 atau 1 ketika Anda mengukurnya, sehingga ada delapan kemungkinan status yang dapat Anda temukan sistem untuk berada di:

$$|000\rangle,|001\rangle,|010\rangle,|011\rangle,|100\rangle,|101\rangle,|110\rangle,|111\rangle $$

Ada delapan kemungkinan status untuk sistem ini karena setiap qubit dapat secara independen menjadi status 0 atau 1 ketika kita mengambil pengukuran. Secara umum, jumlah status yang mungkin sama dengan $2^n$, di mana $n$ adalah jumlah qubit.

Sama seperti dengan satu qubit, status superposisi arbitrer untuk sistem 3-qubit diwakili sebagai jumlah tertimbang dari delapan status ini, di mana bobotnya adalah amplitudo probabilitas:

$$|\psi\rangle=\alpha_0|000\rangle+\alpha_1|001\rangle+\alpha_2|010\rangle+\alpha_3|011\rangle+\alpha_4|100\rangle+\alpha_5|101\rangle+\alpha_6|110\rangle+\alpha_7|111\rangle$$

Sekali lagi, amplitudo $\alpha_i$ adalah angka kompleks yang memenuhi kondisi $\sum\limits_{i=0}^{i=7}|\alpha_i|^2=1$.

Misalnya, Anda dapat menempatkan qubit dalam superposisi seragam dengan menerapkan H ke setiap qubit. Anda kemudian dapat menggunakan superposisi seragam ini untuk membuat generator angka acak kuantum yang menghasilkan angka tiga-bit alih-alih angka satu-bit:

Keadaan dasar Nomor
$\ket{000}$ 0
$\ket{001}$ 4
$\ket{010}$ 2
$\ket{011}$ 6
$\ket{100}$ 1
$\ket{101}$ 5
$\ket{110}$ 3
$\ket{111}$ 7

Catatan

Cara standar untuk menulis string bit adalah dengan memiliki digit terkecil di sebelah kanan dan digit terbesar di sebelah kiri, sama seperti dengan angka desimal biasa. Dalam Q# (dan banyak bahasa pemrograman kuantum lainnya), urutan dibalik sehingga digit terkecil ada di sebelah kiri dan digit terbesar ada di sebelah kanan. DumpMachine Karena fungsi menampilkan status kuantum dalam urutan standar, bilangan bulat desimal yang sesuai dengan status tidak diurutkan secara berurutan dari 0 hingga $n-1$.

Untuk membuat generator angka acak semacam ini, ikuti langkah-langkah berikut:

  1. Ganti kode Anda di Main.qs dengan contoh berikut, lalu simpan file:

    import Std.Diagnostics.*;
import Std.Convert.*;

operation Main() : Int {
    use qubits = Qubit[3];
    ApplyToEach(H, qubits);
    Message("The qubit register in a uniform superposition: ");
    DumpMachine();
    let result = MeasureEachZ(qubits);
    Message("Measuring the qubits collapses the superposition to a basis state.");
    DumpMachine();
    ResetAll(qubits);
    return ResultArrayAsInt(result);
}

  2. Untuk menjalankan program Anda di dalam simulator bawaan, pilih opsi Jalankan di atas operasi Main atau tekan tombol Ctrl + F5. Output Anda muncul di konsol debug.

  3. Periksa output dari DumpMachine dan hasil pengukuran Anda. Misalnya, outputnya mirip dengan yang berikut ini:

    The qubit register in a uniform superposition: 

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
 |000⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |001⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |010⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |011⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |100⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |101⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |110⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |111⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000

Measuring the qubits collapses the superposition to a basis state.

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
 |011⟩ |  1.0000+0.0000𝑖 |   100.0000% |   0.0000

6

    Catatan

    Output Anda mungkin memiliki hasil yang berbeda dari contoh output karena generator angka acak probabilistik. Probabilitas hasilnya deterministik, tetapi hasil pengukuran individu tidak.

Untuk bekerja dengan beberapa kubit, kode Q# Anda memiliki modifikasi berikut:

  • Variabel qubits sekarang mewakili array Qubit yang memiliki panjang tiga.
  • Operasi ApplyToEach dan MeasureEachZ menerapkan operasi kuantum ke beberapa qubit hanya dengan satu baris kode. Pustaka Q# menawarkan banyak fungsi dan operasi yang menyederhanakan pemrograman kuantum untuk Anda.
  • Fungsi ResultArrayAsInt dari Std.Convert pustaka mengubah array biner Result menjadi bilangan bulat desimal.

Output dari DumpMachine menunjukkan bahwa tindakan pengukuran menciutkan status superposisi menjadi salah satu dari delapan status dasar yang mungkin, sama seperti dengan satu qubit. Misalnya, jika Anda mendapatkan hasil 6, ini berarti status sistem berkurang ke $|011\rangle$.

Sekarang mari kita lihat lebih dalam bagaimana sistem berubah saat kita mengukur setiap qubit. Kode sebelumnya menggunakan MeasureEachZ operasi untuk mengukur ketiga qubit sekaligus. Sebagai gantinya, mari kita gunakan perulangan for untuk mengukur qubit satu per satu, dan gunakan DumpMachine untuk melihat status sistem setelah setiap pengukuran.

  1. Ganti kode di Main.qs dengan contoh berikut, lalu simpan file:

    import Std.Diagnostics.*;
import Std.Convert.*;

operation Main() : Int {
    use qubits = Qubit[3];
    ApplyToEach(H, qubits);
    Message("The qubit register is in a uniform superposition: ");
    DumpMachine();
    mutable results = [];
    for q in qubits {
        Message(" ");
        results += [M(q)];
        DumpMachine();
    }
    ResetAll(qubits);
    Message("Your random number is: ");
    return ResultArrayAsInt(results);
}

  2. Untuk menjalankan program Anda di dalam simulator bawaan, pilih opsi Jalankan di atas operasi Main atau tekan tombol Ctrl + F5. Output Anda muncul di konsol debug.

  3. Periksa output dari DumpMachine dan hasil pengukuran Anda.

Output menunjukkan bagaimana setiap pengukuran berturut-turut mengubah status kuantum dan oleh karena itu probabilitas untuk mendapatkan setiap hasil. Misalnya, mari kita periksa setiap bagian output dalam kasus bahwa hasil Anda adalah 5:

  • Persiapan keadaan: Sistem berada dalam status superposisi seimbang setelah anda menerapkan H ke setiap qubit.

    The qubit register is in a uniform superposition: 

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
 |000⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |001⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |010⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |011⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |100⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |101⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |110⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |111⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000

  • Pengukuran pertama: Hasilnya adalah One untuk pengukuran pertama, sehingga sekarang satu-satunya kemungkinan status akhir sistem adalah ketika bit paling kiri bernilai 1. Amplitudo dari keadaan-keadaan di mana kubit paling kiri adalah 0 telah menghilang, dan probabilitas keadaan yang tersisa meningkat dari 12,5% menjadi 25,0% sehingga total probabilitas tetap 100%.

     Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
 |100⟩ |  0.5000+0.0000𝑖 |    25.0000% |   0.0000
 |101⟩ |  0.5000+0.0000𝑖 |    25.0000% |   0.0000
 |110⟩ |  0.5000+0.0000𝑖 |    25.0000% |   0.0000
 |111⟩ |  0.5000+0.0000𝑖 |    25.0000% |   0.0000

  • Pengukuran kedua: Hasilnya adalah Zero untuk pengukuran kedua, jadi sekarang satu-satunya kemungkinan keadaan di mana sistem dapat berakhir adalah keadaan di mana dua bit paling kiri adalah 10. Sekarang kita hanya dibiarkan dengan dua kemungkinan hasil ketika kita mengukur qubit ketiga, dengan probabilitas 50% untuk setiap hasil.

     Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
 |100⟩ |  0.7071+0.0000𝑖 |    50.0000% |   0.0000
 |101⟩ |  0.7071+0.0000𝑖 |    50.0000% |   0.0000

  • Pengukuran ketiga: Dalam pengukuran ketiga, hasilnya adalah One. Sistem telah sepenuhnya diukur, dan karena itu tidak lagi berada dalam keadaan superposisi, sesuai dengan yang diharapkan.

     Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
 |101⟩ |  1.0000+0.0000𝑖 |   100.0000% |   0.0000

Your random number is: 

5

Dengan Q#, Anda dapat membuat sistem qubit, menempatkan qubit ke dalam status superposisi, dan memeriksa bagaimana sistem berubah saat Anda menerapkan operasi kuantum atau mengambil pengukuran.