Mulai cepat: Membuat program pertama Q# Anda

Artikel
10/29/2024

Pelajari cara menulis program dasar Q# yang menunjukkan entanglement, konsep utama 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 mulai cepat ini, Anda membuat status terjerat dua kubit tertentu 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 Kuantum entanglement.

Dalam mulai cepat ini, Anda akan:

Buat file Q#.
Alokasikan sepasang qubit.
Entangle qubits.

Prasyarat

Versi terbaru Visual Studio Code.
Ekstensi Azure Quantum Development Kit (QDK). Untuk detail penginstalan, lihat Menyiapkan Quantum Development Kit.

Membuat Q# file

Buka Visual Studio Code.
Pilih File>Teks Baru.
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 import pernyataan untuk membuka Microsoft.Quantum.Diagnostics pustaka. Ini memberi Anda akses ke semua fungsi dan operasinya, termasuk DumpMachine(), yang nantinya Anda gunakan untuk menampilkan status terjerat.

    import Microsoft.Quantum.Diagnostics.*;

Menentukan operasi

Setelah mengimpor pustaka yang relevan, tentukan operasi kuantum Anda dan nilai input dan outputnya. Untuk mulai 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 dan q1 q2 berada dalam $\ket{0}$ keadaan. Untuk menyiapkan qubit untuk entanglemen, Anda harus memasukkan salah satunya ke dalam superposisi yang merata, di mana ia memiliki 50% kemungkinan 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 yang q1 dihasilkan adalah{1}{\sqrt{2}}$\frac{ (\ket{{0}+\ket{1})$, yang merupakan pengawasan genap dari $\ket{0}$ dan $\ket{{1}$.

Entangle qubits

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

Untuk mulai 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 status terjerat

Sebelum mengukur kubit, penting untuk memverifikasi bahwa kode Anda sebelumnya berhasil menjeratnya. Anda dapat menggunakan DumpMachine operasi, yang merupakan bagian Microsoft.Quantum.Diagnostics dari pustaka, untuk menghasilkan status program Anda Q# saat ini:

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

Mengukur qubit

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

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

Mengatur ulang kubit

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

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

Mengembalikan hasil pengukuran

Terakhir, untuk menyelesaikan Main operasi dan mengamati status terjerat, kembalikan hasil m1 pengukuran 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 menjerat dua qubit dan membuat pasangan Bell.

Program akhir Q# Anda akan terlihat seperti ini:

import Microsoft.Quantum.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 tercakup dalam mulai cepat ini dan membantu Anda menulis program entanglement yang lebih canggih.

Bagikan melalui