Bagikan melalui

Mulai cepat: Membuat program pertama Q# Anda

Pelajari cara menulis program dasar Q# yang mendemonstrasikan entanglement, konsep kunci dalam komputasi kuantum.

Ketika dua atau lebih qubit terjerat, mereka berbagi informasi kuantum, yang berarti apa pun yang terjadi pada satu qubit juga terjadi pada yang lain. Dalam panduan cepat ini, Anda membuat keadaan dua kubit tertentu yang terjerat, yang disebut pasangan Bell. Dalam pasangan Bell, jika Anda mengukur satu qubit dalam $\ket{0}$ keadaan, Anda tahu qubit lainnya juga dalam $\ket{0}$ keadaan tanpa mengukurnya. Untuk informasi selengkapnya, lihat Keterjeratan kuantum.

Dalam panduan cepat ini, Anda akan:

  • Buat file Q#.
  • Alokasikan sepasang qubit.
  • Pertautkan qubit.

Prasyarat

Buatlah file Q#

  1. Buka Visual Studio Code.
  2. Pilih File>File Teks Baru.
  3. Simpan file sebagai Main.qs. Ekstensi .qs menunjukkan Q# program.

Tulis kode Anda Q#

Dalam file Anda Main.qs , ikuti langkah-langkah ini untuk menjerat dan mengukur sepasang qubit.

Mengimpor pustaka kuantum

QDK mencakup Q# pustaka standar dengan fungsi dan operasi yang telah ditentukan sebelumnya untuk program kuantum Anda. Untuk menggunakannya, Anda harus terlebih dahulu mengimpor pustaka yang relevan.

Dalam program Anda, gunakan instruksi import untuk membuka pustaka Std.Diagnostics. Ini memberi Anda akses ke semua fungsi dan operasi pustaka, termasuk DumpMachine, yang nantinya Anda gunakan untuk menampilkan status terjerat.

import Std.Diagnostics.*;

Definisikan operasi

Setelah mengimpor pustaka yang relevan, tentukan operasi kuantum Anda dan nilai input dan outputnya. Dalam panduan memulai cepat ini, operasi Anda adalah Main. Di sinilah Anda akan menulis kode yang tersisa Q# untuk mengalokasikan, memanipulasi, dan mengukur dua qubit.

Main tidak mengambil parameter dan mengembalikan dua Result nilai, baik Zero atau One, yang mewakili hasil pengukuran qubit:

    operation Main() : (Result, Result) {
        // Your entanglement code goes here.
}

Mengalokasikan dua qubit

Operasi Main saat ini kosong, jadi langkah selanjutnya adalah mengalokasikan dua qubit, q1 dan q2. Dalam Q#, Anda mengalokasikan qubit menggunakan use kata kunci:

        // Allocate two qubits, q1 and q2, in the 0 state.
        use (q1, q2) = (Qubit(), Qubit());

Catatan

Dalam Q#, qubit selalu dialokasikan dalam $\ket{0}$ status .

Masukkan satu qubit ke dalam superposisi

Qubit q1 dan q2 berada dalam keadaan $\ket{0}$. Untuk menyiapkan qubit untuk keterbelitan, Anda harus memasukkan salah satunya ke dalam superposisi yang merata, di mana ia memiliki kemungkinan 50% untuk diukur sebagai $\ket{0}$ atau $\ket{1}$.

Anda menempatkan qubit ke dalam superposisi dengan menerapkan Hadamard, H, operasi:

        // Put q1 into an even superposition.
        H(q1);

Status q1 yang dihasilkan adalah$\frac{{1}{\sqrt{2}}(\ket{{0}+\ket{1})$, yang merupakan superposisi genap dari $\ket{0}$ dan $\ket{{1}$.

Entangle qubits

Anda sekarang siap untuk menghubungkan qubit menggunakan operasi controlled-NOT, CNOT. CNOT adalah operasi kontrol yang membutuhkan dua qubit, satu bertindak sebagai kontrol dan yang lainnya sebagai target.

Untuk panduan cepat ini, Anda mengatur q1 sebagai qubit kontrol dan q2 sebagai qubit target. Ini berarti CNOT membalik keadaan q2 ketika status q1 adalah $\ket{1}$.

        // Entangle q1 and q2, making q2 depend on q1.
        CNOT(q1, q2);

Status kedua qubit yang dihasilkan adalah pasangan $\frac{{1}{\sqrt{2}}Bell (\ket{00}+\ket{{11})$.

Tip

Jika Anda ingin mempelajari bagaimana operasi Hadamard dan CNOT mengubah status kubit, lihat Membuat penjeratan dengan operasi kuantum.

Menampilkan keadaan terbelit

Sebelum Anda mengukur qubit, penting untuk memverifikasi bahwa kode Anda sebelumnya berhasil menjeratnya. Gunakan operasi DumpMachine, yang merupakan bagian dari pustaka Std.Diagnostics, untuk menghasilkan status saat ini dari program Q# Anda.

    // Show the entangled state of the qubits.
    DumpMachine();

Mengukur qubit

Sekarang setelah Anda memverifikasi kubit terjerat, Anda dapat menggunakan operasi M untuk mengukurnya. Mengukur q1 dan q2 mengubah status kuantum mereka menjadi Zero atau One dengan probabilitas yang sama.

Di Q#, Anda menggunakan let kata kunci untuk mendeklarasikan variabel baru. Untuk menyimpan hasil q1 pengukuran dan q2, deklarasikan variabel m1 dan m2, masing-masing:

        // Measure q1 and q2 and store the results in m1 and m2.
        let (m1, m2) = (M(q1), M(q2));

Atur ulang kubit

Sebelum dirilis, pada akhir setiap program Q#, qubit harus berada dalam keadaan $\ket{0}$. Anda melakukan ini dengan operasi Reset.

        // Reset q1 and q2 to the 0 state.
        Reset(q1);
        Reset(q2);

Mengembalikan hasil pengukuran

Akhirnya, untuk menyelesaikan operasi Main dan mengamati status terjerat, tampilkan hasil pengukuran m1 dan m2.

        // Return the measurement results.
        return (m1, m2);

Tip

Jika Anda ingin mempelajari lebih lanjut tentang Q# fungsi atau operasi, arahkan mouse ke atasnya.

Cuplikan layar detail yang muncul saat Anda mengarahkan mouse ke operasi 'H' di Visual Studio Code.

Jalankan kode Anda Q#

Selamat! Anda menulis program Q# yang menghubungkan dua qubit dan membuat pasangan Bell.

Program akhir Q# Anda akan terlihat seperti ini:

import Std.Diagnostics.*;

operation Main() : (Result, Result) {  
    // Allocate two qubits, q1 and q2, in the 0 state.
    use (q1, q2) = (Qubit(), Qubit());
    
    // Put q1 into an even superposition.
    // It now has a 50% chance of being measured as 0 or 1.
    H(q1);
    
    // Entangle q1 and q2, making q2 depend on q1.
    CNOT(q1, q2);
    
    // Show the entangled state of the qubits.
    DumpMachine();
    
    // Measure q1 and q2 and store the results in m1 and m2.
    let (m1, m2) = (M(q1), M(q2));
    
    // Reset q1 and q2 to the 0 state.
    Reset(q1);
    Reset(q2);
    
    // Return the measurement results.
    return (m1, m2);
}

Untuk menjalankan program Anda dan melihat hasil kedua qubit, pilih Jalankan di atas Main operasi atau tekan Ctrl+F5

Q# Cuplikan layar file di Visual Studio Code memperlihatkan tempat menemukan perintah 'Jalankan'.

Anda dapat menjalankan program beberapa kali, masing-masing dengan hasil yang berbeda di konsol debug. Ini menunjukkan sifat probabilistik pengukuran kuantum dan terjeratnya qubit.

Misalnya, jika hasilnya adalah Zero, konsol debug Anda akan terlihat seperti ini:

DumpMachine:

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
  |00⟩ |  0.7071+0.0000𝑖 |    50.0000% |   0.0000
  |11⟩ |  0.7071+0.0000𝑖 |    50.0000% |   0.0000

Result: "(Zero, Zero)"

Langkah selanjutnya

Untuk mempelajari selengkapnya tentang entanglemen kuantum dengan Q#, lihat Tutorial: Menjelajahi entanglemen kuantum dengan Q#. Tutorial ini memperluas konsep yang dibahas dalam panduan cepat ini dan membantu Anda menulis program keterikatan yang lebih canggih.

  • Last updated on