Bagikan melalui

Tutorial: Menjelajahi entanglemen kuantum dengan Q#

  • Artikel

Dalam tutorial ini, Anda menulis Q# program yang memanipulasi dan mengukur qubit dan menunjukkan efek superposisi dan entanglemen. Anda menyiapkan dua qubit dalam keadaan kuantum tertentu, mempelajari cara mengoperasikan qubit dengan Q# untuk mengubah keadaan mereka, dan menunjukkan efek superposisi dan entanglemen. Anda membangun program anda Q# sepotong demi sepotong untuk memperkenalkan status qubit, operasi, dan pengukuran.

Berikut adalah beberapa konsep utama yang perlu dipahami sebelum Anda mulai:

  • Di mana bit klasik memiliki nilai biner tunggal seperti 0 atau 1, status qubit dapat berada dalam superposisi dua status kuantum, 0 dan 1. Setiap keadaan kuantum yang mungkin memiliki amplitudo probabilitas yang terkait.
  • Tindakan mengukur qubit menghasilkan hasil biner dengan probabilitas tertentu, dan mengubah status qubit keluar dari superposisi.
  • Beberapa qubit dapat dijerat skema sehingga mereka tidak dapat dijelaskan secara independen satu sama lain. Artinya, apa pun yang terjadi pada satu qubit dalam pasangan yang terikat juga terjadi pada qubit lainnya.

Dalam tutorial ini, Anda akan mempelajari cara:

  • Buat Q# operasi untuk menginisialisasi qubit ke status yang diinginkan.
  • Memasukkan qubit ke dalam superposisi.
  • Ikat sepasang qubit.
  • Mengukur qubit dan mengamati hasilnya.

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 untuk Azure Quantum, Anda memerlukan:

  • Akun email Microsoft (MSA).

Untuk informasi selengkapnya tentang Copilot, lihat Menjelajahi Azure Quantum.

Menginisialisasi qubit ke status yang diketahui

Langkah pertama adalah mendefinisikan operasi Q# yang menginisialisasi qubit ke status yang diketahui. Operasi ini dapat dipanggil untuk mengatur qubit ke status klasik, yang berarti bahwa, ketika diukur, operasi ini mengembalikan Zero 100% dari waktu atau mengembalikan One 100% dari waktu. Mengukur qubit mengembalikan Q# jenis Result, yang hanya dapat memiliki nilai Zero atau One.

Buka Copilot untuk Azure Quantum dan salin kode berikut ke jendela editor kode. Jangan pilih Jalankan; Anda akan menjalankan kode nanti dalam tutorial.

import Microsoft.Quantum.Intrinsic.*;
import Microsoft.Quantum.Canon.*;

operation SetQubitState(desired : Result, target : Qubit) : Unit {
    if desired != M(target) {
        X(target);
    }
}

Contoh kode memperkenalkan dua operasi standar, M dan X, yang mengubah status qubit.

Operasi SetQubitState:

  1. Mengambil dua parameter: jenis Result, bernama desired, yang mewakili status yang diinginkan agar qubit berada di (Zero atau One), dan jenis Qubit.
  2. Melakukan operasi pengukuran, M, yang mengukur status qubit (Zero atau One) dan membandingkan hasilnya dengan nilai yang ditentukan dalam desired.
  3. Jika pengukuran tidak sesuai dengan nilai yang dibandingkan, ia menjalankan operasi X, yang membalik status qubit ke tempat peluang pengukuran mengembalikan Zero dan One dibalik. Dengan cara ini, SetQubitState selalu menempatkan qubit target dalam status yang diinginkan.

Menulis operasi pengujian untuk menguji status Bell

Selanjutnya, untuk menunjukkan efek operasi SetQubitState, buat operasi lain bernama Main. Operasi ini akan mengalokasikan dua qubit, panggilan SetQubitState untuk mengatur qubit pertama ke status yang diketahui, lalu mengukur qubit untuk melihat hasilnya.

Salin kode berikut ke jendela editor kode, di SetQubitState bawah operasi.

operation Main() : (Int, Int, Int, Int) {
    mutable numOnesQ1 = 0;
    mutable numOnesQ2 = 0;
    let count = 1000;
    let initial = One;

    // allocate the qubits
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);
        
        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2);           

        // Count the number of 'Ones' returned:
        if resultQ1 == One {
            numOnesQ1 += 1;
        }
        if resultQ2 == One {
            numOnesQ2 += 1;
        }
    }

    // reset the qubits
    SetQubitState(Zero, q1);             
    SetQubitState(Zero, q2);
    

    // Display the times that |0> is returned, and times that |1> is returned
    Message($"Q1 - Zeros: {count - numOnesQ1}");
    Message($"Q1 - Ones: {numOnesQ1}");
    Message($"Q2 - Zeros: {count - numOnesQ2}");
    Message($"Q2 - Ones: {numOnesQ2}");
    return (count - numOnesQ1, numOnesQ1, count - numOnesQ2, numOnesQ2 );
}

Dalam kode, count variabel dan initial diatur ke 1000 dan One masing-masing. Ini menginisialisasi qubit pertama ke One dan mengukur setiap qubit 1000 kali.

Operasi Main:

  1. Mengatur variabel untuk penghitung dan status qubit awal.
  2. Memanggil pernyataan use untuk menginisialisasi dua qubit.
  3. Berulang untuk iterasi count. Untuk setiap perulangan,
    1. Memanggil SetQubitState untuk mengatur nilai initial tertentu pada qubit pertama.
    2. Memanggil SetQubitState lagi untuk mengatur qubit kedua ke status Zero.
    3. Menggunakan operasi M untuk mengukur setiap qubit.
    4. Menyimpan jumlah pengukuran untuk setiap qubit yang mengembalikan One.
  4. Setelah perulangan selesai, ia memanggil SetQubitState lagi untuk mengatur ulang qubit ke status yang diketahui (Zero) agar memungkinkan yang lain mengalokasikan qubit dalam status yang diketahui. Pengaturan ulang diperlukan oleh use pernyataan.
  5. Terakhir, ini menggunakan Message fungsi untuk mencetak hasil ke jendela output Copilot sebelum mengembalikan hasilnya.

Jalankan kode di Copilot untuk Azure Quantum

Sebelum beralih ke prosedur untuk superposisi dan penjeratan, Anda dapat menguji kode hingga titik ini untuk melihat inisialisasi dan pengukuran qubit.

Untuk menjalankan kode sebagai program mandiri, Q# pengkompilasi di Copilot perlu tahu di mana harus memulai program. Karena tidak ada namespace yang ditentukan, pengkompilasi mengenali titik masuk default sebagai Main operasi. Untuk informasi selengkapnya, lihat Proyek dan namespace implisit.

Program Anda Q# hingga saat ini akan terlihat seperti ini:

import Microsoft.Quantum.Intrinsic.*;
import Microsoft.Quantum.Canon.*;

operation SetQubitState(desired : Result, target : Qubit) : Unit {
    if desired != M(target) {
        X(target);
    }
}

operation Main() : (Int, Int, Int, Int) {
    mutable numOnesQ1 = 0;
    mutable numOnesQ2 = 0;
    let count = 1000;
    let initial = One;

    // allocate the qubits
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);
        
        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2);           

        // Count the number of 'Ones' returned:
        if resultQ1 == One {
            numOnesQ1 += 1;
        }
        if resultQ2 == One {
            numOnesQ2 += 1;
        }
    }

    // reset the qubits
    SetQubitState(Zero, q1);             
    SetQubitState(Zero, q2);
        
    
    // Display the times that |0> is returned, and times that |1> is returned
    Message($"Q1 - Zeros: {count - numOnesQ1}");
    Message($"Q1 - Ones: {numOnesQ1}");
    Message($"Q2 - Zeros: {count - numOnesQ2}");
    Message($"Q2 - Ones: {numOnesQ2}");
    return (count - numOnesQ1, numOnesQ1, count - numOnesQ2, numOnesQ2 );

}

Salin dan tempel sampel kode lengkap ke dalam jendela kode Copilot for Azure Quantum, atur penggeser untuk jumlah tembakan ke "1", dan pilih Jalankan. Hasilnya ditampilkan dalam histogram dan di bidang Hasil .

Q1 - Zeros: 0
Q1 - Ones: 1000
Q2 - Zeros: 1000
Q2 - Ones: 0

Karena qubit belum dimanipulasi, mereka telah mempertahankan nilai awalnya: qubit pertama mengembalikan One setiap saat, dan qubit kedua mengembalikan Zero.

Jika Anda mengubah nilai initial menjadi Zero dan menjalankan program lagi, Anda harus mengamati bahwa qubit pertama juga kembali Zero setiap saat.

Q1 - Zeros: 1000
Q1 - Ones: 0
Q2 - Zeros: 1000
Q2 - Ones: 0

Tip

Pilih Ctrl-Z atau Edit > Batalkan dan simpan file Anda setiap kali Anda memperkenalkan perubahan pengujian ke kode sebelum menjalankannya lagi.

Masukkan qubit ke dalam superposisi

Saat ini, qubit dalam program ini semuanya dalam status klasik, yaitu, mereka berupa 1 atau 0. Anda tahu ini karena program menginisialisasi qubit ke status yang diketahui, dan Anda belum menambahkan proses apa pun untuk memanipulasinya. Sebelum menjerat kubit, Anda menempatkan qubit pertama ke dalam status superposisi, di mana pengukuran kubit mengembalikan Zero ~50% dari waktu dan One ~50% dari waktu. Secara konseptual, qubit dapat dianggap memiliki probabilitas yang sama untuk mengukur baik Zero atau One.

Untuk menempatkan qubit dalam superposisi, Q# menyediakan H, atau Hadamard, operasi. X Ingat operasi dari Inisialisasi qubit ke prosedur status yang diketahui sebelumnya, yang membalikkan qubit dari 0 hingga 1 (atau sebaliknya); H operasi membalik qubit setengah jalan ke dalam keadaan probabilitas Zero yang sama atau One. Ketika diukur, qubit dalam superposisi harus mengembalikan hasil kira-kira jumlah Zero dan One yang sama.

Ubah kode dalam Main operasi dengan mengatur ulang nilai awal ke One dan menyisipkan baris untuk H operasi:

for test in 1..count {
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);
        
        H(q1);                // Add the H operation after initialization and before measurement

        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2); 
        ...

Sekarang ketika Anda menjalankan program, Anda dapat melihat hasil qubit pertama dalam superposisi.

Q1 - Zeros: 523            // results vary
Q1 - Ones: 477
Q2 - Zeros: 1000
Q2 - Ones: 0

Setiap kali Anda menjalankan program, hasil untuk qubit pertama sedikit bervariasi, tetapi akan mendekati 50% One dan 50% Zero, sementara hasil untuk qubit kedua tetap Zero sepanjang waktu.

Q1 - Zeros: 510           
Q1 - Ones: 490
Q2 - Zeros: 1000
Q2 - Ones: 0

Lakukan inisialisasi qubit pertama untuk mengembalikan Zero hasil yang sama.

Q1 - Zeros: 504           
Q1 - Ones: 496
Q2 - Zeros: 1000
Q2 - Ones: 0

Catatan

Dengan memindahkan slider di Copilot untuk Azure Quantum dan meningkatkan jumlah bidikan, Anda dapat melihat bagaimana hasil superposisi sedikit bervariasi selama distribusi bidikan.

Ikat dua qubit

Seperti disebutkan sebelumnya, qubit terikat disambungkan sehingga qubit tersebut tidak dapat dijelaskan secara tersendiri satu sama lain. Artinya, apa pun yang terjadi pada satu qubit juga terjadi pada qubit yang terkait. Ini memungkinkan Anda untuk mengetahui status yang dihasilkan dari satu qubit tanpa mengukurnya, hanya dengan mengukur status qubit lainnya. (Contoh ini menggunakan dua qubit; namun, dimungkinkan juga untuk mengikat tiga qubit atau lebih).

Untuk mengaktifkan keterikatan, Q# menyediakan operasi CNOT, yang merupakan singkatan dari Controlled-NOT. Hasil menjalankan operasi ini pada dua qubit ialah membalik qubit kedua jika qubit pertama adalah One.

Tambahkan operasi CNOT ke program Anda segera setelah operasi H. Program penuh Anda akan terlihat seperti ini:

import Microsoft.Quantum.Intrinsic.*;
import Microsoft.Quantum.Canon.*;

    operation SetQubitState(desired : Result, target : Qubit) : Unit {
        if desired != M(target) {
            X(target);
        }
    }

operation Main() : (Int, Int, Int, Int) {
    mutable numOnesQ1 = 0;
    mutable numOnesQ2 = 0;
    let count = 1000;
    let initial = Zero;

    // allocate the qubits
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);
    
        H(q1);            
        CNOT(q1, q2);      // Add the CNOT operation after the H operation

        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2);           

        // Count the number of 'Ones' returned:
        if resultQ1 == One {
            numOnesQ1 += 1;
        }
        if resultQ2 == One {
            numOnesQ2 += 1;
        }
    }

    // reset the qubits
    SetQubitState(Zero, q1);             
    SetQubitState(Zero, q2);
    

    // Display the times that |0> is returned, and times that |1> is returned
    Message($"Q1 - Zeros: {count - numOnesQ1}");
    Message($"Q1 - Ones: {numOnesQ1}");
    Message($"Q2 - Zeros: {count - numOnesQ2}");
    Message($"Q2 - Ones: {numOnesQ2}");
    return (count - numOnesQ1, numOnesQ1, count - numOnesQ2, numOnesQ2 );

    }

Sekarang ketika Anda menjalankan program, Anda akan melihat sesuatu seperti:

Q1 - Zeros: 502           // results will vary
Q1 - Ones: 498
Q2 - Zeros: 502
Q2 - Ones: 498

Perhatikan bahwa statistik untuk kubit pertama belum berubah (masih ada peluang ~ 50/50 dari atau ZeroOne setelah pengukuran), tetapi hasil pengukuran untuk kubit kedua selalu sama dengan pengukuran kubit pertama, tidak peduli berapa kali Anda menjalankan program. Operasi CNOT telah mengikat dua qubit, sehingga apa pun yang terjadi pada salah satu dari mereka, terjadi pada yang lain.

Prasyarat

Untuk mengembangkan dan menjalankan sampel kode di lingkungan pengembangan lokal Anda:

Membuat file baru Q#

  1. Buka Visual Studio Code dan pilih File > Teks Baru untuk membuat file baru.
  2. Simpan file sebagai CreateBellStates.qs. File ini akan berisi Q# kode untuk program Anda.

Menginisialisasi qubit ke status yang diketahui

Langkah pertama adalah mendefinisikan operasi Q# yang menginisialisasi qubit ke status yang diketahui. Operasi ini dapat dipanggil untuk mengatur qubit ke status klasik, yang berarti mengembalikan Zero 100% dari waktu atau mengembalikan One 100% dari waktu. Zero dan One adalah nilai-nilai Q# yang mewakili hanya dua kemungkinan hasil pengukuran qubit.

Buka CreateBellStates.qs dan salin kode berikut:

import Microsoft.Quantum.Intrinsic.*;
import Microsoft.Quantum.Canon.*;

operation SetQubitState(desired : Result, target : Qubit) : Unit {
    if desired != M(target) {
        X(target);
    }
}

Contoh kode memperkenalkan dua operasi standar, M dan X, yang mengubah status qubit.

Operasi SetQubitState:

  1. Mengambil dua parameter: jenis Result, bernama desired, yang mewakili status yang diinginkan agar qubit berada di (Zero atau One), dan jenis Qubit.
  2. Melakukan operasi pengukuran, M, yang mengukur status qubit (Zero atau One) dan membandingkan hasilnya dengan nilai yang ditentukan dalam desired.
  3. Jika pengukuran tidak sesuai dengan nilai yang dibandingkan, ia menjalankan operasi X, yang membalik status qubit ke tempat peluang pengukuran mengembalikan Zero dan One dibalik. Dengan cara ini, SetQubitState selalu menempatkan qubit target dalam status yang diinginkan.

Menulis operasi pengujian untuk menguji status Bell

Selanjutnya, untuk menunjukkan efek operasi SetQubitState, buat operasi lain bernama Main. Operasi ini mengalokasikan dua qubit, panggilan SetQubitState untuk mengatur qubit pertama ke status yang diketahui, lalu mengukur qubit untuk melihat hasilnya.

Tambahkan operasi berikut ke file CreateBellStates.qs Anda setelah operasi SetQubitState:

operation Main() : (Int, Int, Int, Int) {
    mutable numOnesQ1 = 0;
    mutable numOnesQ2 = 0;
    let count = 1000;
    let initial = One;

    // allocate the qubits
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);
        
        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2);           

        // Count the number of 'Ones' returned:
        if resultQ1 == One {
            numOnesQ1 += 1;
        }
        if resultQ2 == One {
            numOnesQ2 += 1;
        }
    }

    // reset the qubits
    SetQubitState(Zero, q1);             
    SetQubitState(Zero, q2);
    

    // Display the times that |0> is returned, and times that |1> is returned
    Message($"Q1 - Zeros: {count - numOnesQ1}");
    Message($"Q1 - Ones: {numOnesQ1}");
    Message($"Q2 - Zeros: {count - numOnesQ2}");
    Message($"Q2 - Ones: {numOnesQ2}");
    return (count - numOnesQ1, numOnesQ1, count - numOnesQ2, numOnesQ2 );
}

Dalam kode, count variabel dan initial diatur ke 1000 dan One masing-masing. Langkah ini menginisialisasi qubit pertama ke One dan mengukur setiap qubit 1000 kali.

Operasi Main:

  1. Menggunakan dua parameter: count, berapa kali untuk menjalankan pengukuran, dan initial, status yang diinginkan untuk menginisialisasi qubit.
  2. Memanggil pernyataan use untuk menginisialisasi dua qubit.
  3. Berulang untuk iterasi count. Untuk setiap perulangan,
    1. Memanggil SetQubitState untuk mengatur nilai initial tertentu pada qubit pertama.
    2. Memanggil SetQubitState lagi untuk mengatur qubit kedua ke status Zero.
    3. Menggunakan operasi M untuk mengukur setiap qubit.
    4. Menyimpan jumlah pengukuran untuk setiap qubit yang mengembalikan One.
  4. Setelah perulangan selesai, ia memanggil SetQubitState lagi untuk mengatur ulang qubit ke status yang diketahui (Zero) agar memungkinkan yang lain mengalokasikan qubit dalam status yang diketahui. Mengatur ulang kubit diperlukan oleh use pernyataan .
  5. Akhirnya, ia menggunakan fungsi Message untuk mencetak pesan ke konsol sebelum mengembalikan hasil.

Menjalankan kode

Sebelum beralih ke prosedur untuk superposisi dan ikatan, uji kode hingga titik ini untuk melihat inisialisasi dan pengukuran qubit.

Untuk menjalankan kode sebagai program mandiri, pengkompilasi Q# perlu tahu di mana harus memulai program. Karena tidak ada namespace yang ditentukan, pengkompilasi mengenali titik masuk default sebagai Main operasi. Untuk informasi selengkapnya, lihat Proyek dan namespace implisit.

  1. File Anda CreateBellStates.qs hingga titik ini sekarang akan terlihat seperti ini:

    import Microsoft.Quantum.Intrinsic.*;
import Microsoft.Quantum.Canon.*;

operation SetQubitState(desired : Result, target : Qubit) : Unit {
    if desired != M(target) {
        X(target);
    }
}

operation Main() : (Int, Int, Int, Int) {
    mutable numOnesQ1 = 0;
    mutable numOnesQ2 = 0;
    let count = 1000;
    let initial = One;

    // allocate the qubits
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);

        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2);           

        // Count the number of 'Ones' returned:
        if resultQ1 == One {
            numOnesQ1 += 1;
        }
        if resultQ2 == One {
            numOnesQ2 += 1;
        }
    }

    // reset the qubits
    SetQubitState(Zero, q1);             
    SetQubitState(Zero, q2);


    // Display the times that |0> is returned, and times that |1> is returned
    Message($"Q1 - Zeros: {count - numOnesQ1}");
    Message($"Q1 - Ones: {numOnesQ1}");
    Message($"Q2 - Zeros: {count - numOnesQ2}");
    Message($"Q2 - Ones: {numOnesQ2}");
    return (count - numOnesQ1, numOnesQ1, count - numOnesQ2, numOnesQ2 );
}

  2. Sebelum menjalankan program, pastikan profil target diatur ke Tidak Dibatasi. Pilih Tampilkan -> Palet Perintah, cari QIR, pilih Q#: Atur profil target QIR Azure Quantum, lalu pilih Q#: tidak dibatasi.

    Catatan

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

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

  4. Output Anda muncul di konsol debug.

    Q1 - Zeros: 0
Q1 - Ones: 1000
Q2 - Zeros: 1000
Q2 - Ones: 0

    Karena qubit belum dimanipulasi, mereka telah mempertahankan nilai awalnya: qubit pertama mengembalikan One setiap saat, dan qubit kedua mengembalikan Zero.

  5. Jika Anda mengubah nilai initial menjadi Zero dan menjalankan program lagi, Anda harus mengamati bahwa qubit pertama juga kembali Zero setiap saat.

    Q1 - Zeros: 1000
Q1 - Ones: 0
Q2 - Zeros: 1000
Q2 - Ones: 0

Tip

Pilih Ctrl-Z atau Edit > Batalkan dan simpan file Anda setiap kali Anda memperkenalkan perubahan pengujian ke kode sebelum menjalankannya lagi.

Masukkan qubit ke dalam superposisi

Saat ini, qubit dalam program ini semuanya dalam status klasik, yaitu, mereka berupa 1 atau 0. Anda tahu ini karena program menginisialisasi qubit ke status yang diketahui, dan Anda belum menambahkan proses apa pun untuk memanipulasinya. Sebelum menjerat kubit, Anda menempatkan qubit pertama ke dalam status superposisi, di mana pengukuran kubit mengembalikan Zero 50% dari waktu dan One 50% dari waktu. Secara konseptual, qubit dapat dianggap sebagai setengah jalan antara Zero dan One.

Untuk menempatkan qubit dalam superposisi, Q# menyediakan H, atau Hadamard, operasi. X Ingat operasi dari Inisialisasi qubit ke prosedur status yang diketahui sebelumnya, yang membalikkan qubit dari Zero ke One (atau sebaliknya); H operasi membalik qubit setengah jalan ke dalam keadaan probabilitas Zero yang sama atau One. Ketika diukur, qubit dalam superposisi harus mengembalikan hasil kira-kira jumlah Zero dan One yang sama.

  1. Ubah kode dalam operasi Main untuk menyertakan operasi H:

    for test in 1..count {
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);

        H(q1);                // Add the H operation after initialization and before measurement

        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2); 
        ...

  2. Sekarang ketika Anda menjalankan program, Anda dapat melihat hasil qubit pertama dalam superposisi:

    Q1 - Zeros: 523            // results will vary
Q1 - Ones: 477
Q2 - Zeros: 1000
Q2 - Ones: 0

  3. Setiap kali Anda menjalankan program, hasil untuk qubit pertama sedikit bervariasi, tetapi akan mendekati 50% One dan 50% Zero, sementara hasil untuk qubit kedua tetap Zero sepanjang waktu.

    Q1 - Zeros: 510           
Q1 - Ones: 490
Q2 - Zeros: 1000
Q2 - Ones: 0

  4. Lakukan inisialisasi qubit pertama untuk mengembalikan Zero hasil yang sama.

    Q1 - Zeros: 504           
Q1 - Ones: 496
Q2 - Zeros: 1000
Q2 - Ones: 0

Ikat dua qubit

Seperti disebutkan sebelumnya, qubit terikat disambungkan sehingga qubit tersebut tidak dapat dijelaskan secara tersendiri satu sama lain. Artinya, apa pun yang terjadi pada satu qubit juga terjadi pada qubit yang terkait. Ini memungkinkan Anda untuk mengetahui status yang dihasilkan dari satu qubit tanpa mengukurnya, hanya dengan mengukur status qubit lainnya. (Contoh ini menggunakan dua qubit; namun, dimungkinkan juga untuk mengikat tiga qubit atau lebih).

Untuk mengaktifkan keterikatan, Q# menyediakan operasi CNOT, yang merupakan singkatan dari Controlled-NOT. Hasil menjalankan operasi ini pada dua qubit ialah membalik qubit kedua jika qubit pertama adalah One.

  1. Tambahkan operasi CNOT ke program Anda segera setelah operasi H. Program penuh Anda akan terlihat seperti ini:

    import Microsoft.Quantum.Intrinsic.*;
import Microsoft.Quantum.Canon.*;

    operation SetQubitState(desired : Result, target : Qubit) : Unit {
        if desired != M(target) {
            X(target);
        }
    }

operation Main() : (Int, Int, Int, Int) {
    mutable numOnesQ1 = 0;
    mutable numOnesQ2 = 0;
    let count = 1000;
    let initial = Zero;

    // allocate the qubits
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);

        H(q1);            
        CNOT(q1, q2);      // Add the CNOT operation after the H operation

        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2);           

        // Count the number of 'Ones' returned:
        if resultQ1 == One {
            numOnesQ1 += 1;
        }
        if resultQ2 == One {
            numOnesQ2 += 1;
        }
    }

    // reset the qubits
    SetQubitState(Zero, q1);             
    SetQubitState(Zero, q2);


    // Display the times that |0> is returned, and times that |1> is returned
    Message($"Q1 - Zeros: {count - numOnesQ1}");
    Message($"Q1 - Ones: {numOnesQ1}");
    Message($"Q2 - Zeros: {count - numOnesQ2}");
    Message($"Q2 - Ones: {numOnesQ2}");
    return (count - numOnesQ1, numOnesQ1, count - numOnesQ2, numOnesQ2 );

    }


    Q1 - Zeros: 502           
Q1 - Ones: 498       // results will vary
Q2 - Zeros: 502
Q2 - Ones: 498
Result: "(502, 498, 502, 498)"

Statistik untuk qubit pertama tidak berubah (kemungkinan 50/50 dari Zero atau One setelah pengukuran), tetapi hasil pengukuran untuk qubit kedua selalu sama dengan pengukuran qubit pertama. Operasi ini CNOT menjerat dua qubit, sehingga apa pun yang terjadi pada salah satu dari mereka, terjadi pada yang lain.

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 Tampilkan -> Palet Perintah, atau tekan Ctrl+Shift+P, dan ketik "histogram" yang akan 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 ditampilkan di Q# jendela histogram.

  3. Setiap bilah dalam histogram sesuai dengan kemungkinan hasil, dan tingginya mewakili berapa kali hasil tersebut diamati. Dalam hal ini, ada 50 hasil unik yang berbeda. Perhatikan bahwa untuk setiap hasil hasil pengukuran untuk qubit pertama dan kedua selalu sama.

    Cuplikan layar jendela Q# histogram di Visual Studio Code.

    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.

    Cuplikan layar jendela Q# histogram di Visual Studio Code memperlihatkan cara menampilkan pengaturan.

Konten terkait

Jelajahi tutorial Q# lainnya:

  • Algoritma pencarian Grover menunjukkan cara menulis Q# program yang menggunakan algoritma pencarian Grover.
  • Quantum Fourier Transform 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.