Tutorial: Menjelajahi belitan kuantum dengan Q#

Dalam tutorial ini, Anda menulis Q# program yang menyiapkan dua qubit dalam keadaan kuantum tertentu, mengoperasikan qubit untuk membelitkannya satu sama lain, dan melakukan pengukuran untuk menunjukkan efek superposisi dan belitan. Anda membangun program Anda Q# sepotong demi sepotong untuk memperkenalkan status qubit, operasi kuantum, dan pengukuran.

Sebelum memulai, tinjau konsep komputasi kuantum berikut:

• Bit klasik menyimpan satu nilai biner seperti 0 atau 1, tetapi qubit dapat berada dalam superposisi dua status, 0 dan 1. Setiap kemungkinan status qubit dijelaskan oleh sekumpulan amplitudo probabilitas.
• Ketika Anda mengukur status qubit, Anda selalu mendapatkan 0 atau 1. Probabilitas setiap hasil ditentukan oleh amplitudo probabilitas yang menentukan status superposisi saat Anda melakukan pengukuran.
• Beberapa kubit dapat terjerat sedemikian rupa sehingga Anda tidak dapat menggambarkannya secara independen satu sama lain. Ketika Anda mengukur satu qubit dalam pasangan terjerat, Anda juga mendapatkan informasi tentang qubit lainnya tanpa mengukurnya.

Dalam tutorial ini, Anda akan belajar cara:

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

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 dengan Copilot untuk Microsoft Quantum, Anda harus memiliki akun email Microsoft (MSA).

Untuk informasi selengkapnya tentang Copilot untuk Microsoft Quantum, lihat Menjelajahi Azure Quantum.

Menginisialisasi qubit ke status yang diketahui

Langkah pertama adalah menentukan Q# operasi yang menginisialisasi qubit ke status klasik yang diinginkan, baik 0 atau 1. Operasi ini mengukur qubit dalam status kuantum umum, yang mengembalikan Q#Result nilai jenis baik Zero atau One. Jika hasil pengukuran berbeda dari status yang diinginkan, maka operasi membalikkan status sehingga operasi mengembalikan status yang diinginkan 100% dari waktu.

Buka Copilot untuk Microsoft Quantum, kosongkan kode default, lalu salin kode berikut ke jendela editor kode. Anda tidak dapat menjalankan kode ini dengan sendirinya karena belum menjadi program lengkap Q# .

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

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

Berikut adalah deskripsi terperinci tentang cara SetQubitState kerja operasi:

1. Mengambil dua parameter: Result parameter jenis bernama desired yang mewakili status yang diinginkan agar qubit berada di (Zero atau One), dan Qubit parameter jenis.
2. Melakukan operasi pengukuran, M, yang mengukur status qubit (Zero atau One) dan membandingkan hasilnya dengan nilai yang Anda berikan untuk desired.
3. Jika hasil pengukuran tidak cocok dengan nilai untuk desired, maka X operasi diterapkan ke qubit. Operasi ini membalikkan status qubit sehingga probabilitas pengukuran untuk Zero dan One dibalik.

Tulis operasi uji untuk menguji keadaan Bell

Untuk memanggil SetQubitState operasi dalam program Anda Q# , 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.

Salin kode berikut ke dalam jendela editor kode, 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, variabel count dan initial masing-masing diatur ke 1000 dan One. Ini menginisialisasi qubit pertama ke One dan mengukur setiap qubit 1000 kali.

Operasi Main melakukan tindakan berikut:

1. Mengatur variabel untuk jumlah bidikan (count) dan status kubit awal (One).
2. Memanggil pernyataan use untuk menginisialisasi dua qubit.
3. Mengulangi percobaan sebanyak count kali.
4. Dalam perulangan, panggilan SetQubitState untuk mengatur nilai yang ditentukan initial pada qubit pertama, lalu memanggil SetQubitState lagi untuk mengatur qubit kedua ke Zero status.
5. Dalam perulangan, operasi M diterapkan untuk melakukan pengukuran pada setiap qubit, lalu menyimpan jumlah hasil pengukuran untuk setiap qubit yang mengembalikan One.
6. Setelah perulangan selesai, panggil SetQubitState lagi untuk mengatur ulang qubit ke status yang diketahui (Zero). Anda harus mengatur ulang kubit yang Anda alokasikan dengan use pernyataan .
7. Memanggil fungsi Message untuk mencetak hasil Anda di jendela keluaran.

Menjalankan kode di Copilot untuk Microsoft Quantum

Sebelum Anda menulis kode untuk superposisi dan entanglement, lakukan pengujian pada program Anda saat ini agar dapat melihat inisialisasi dan pengukuran kubit.

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

Program Anda Q# sekarang terlihat seperti ini:

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 jendela Kode Copilot untuk Microsoft Quantum , atur penggelas untuk jumlah bidikan ke "1", lalu pilih Jalankan. Hasil ditampilkan dalam histogram dan di bidang Hasil .

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

Program Anda belum memodifikasi status qubit, sehingga pengukuran qubit pertama selalu mengembalikan One, dan qubit kedua selalu mengembalikan Zero.

Jika Anda mengubah nilai menjadi initialZero dan menjalankan program lagi, maka qubit pertama juga selalu mengembalikan Zero.

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

Menempatkan qubit ke dalam status superposisi

Saat ini, qubit dalam program Anda dalam keadaan klasik, baik 1 atau 0, seperti bit pada komputer biasa. Untuk menjerat qubit, Anda harus terlebih dahulu menempatkan salah satu qubit ke dalam status superposisi yang sama. Pengukuran qubit dalam keadaan superposisi yang setara memiliki 50% kemungkinan kembali Zero dan 50% kemungkinan mengembalikan One.

Untuk menempatkan qubit ke dalam status superposisi, gunakan Q#Hoperasi , atau Hadamard, . Operasi H mengonversi qubit yang berada dalam status Zero atau One murni menjadi status yang setengah jalan antara Zero dan One.

Ubah kode Anda pada operasi Main. Reset nilai awal ke One dan sisipkan 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); 
        ...

Jalankan program Anda lagi. Karena qubit pertama berada dalam superposisi yang sama ketika Anda mengukurnya, Anda mendekati hasil 50/50 untuk Zero dan One. Misalnya, output Anda terlihat mirip dengan ini:

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

Setiap kali Anda menjalankan program, hasil untuk qubit pertama sedikit bervariasi, tetapi hampir 50% One dan 50% Zero, sementara hasil untuk kubit kedua masih selalu Zero.

Inisialisasi qubit pertama ke Zero alih-alih One dan jalankan program lagi. Anda mendapatkan hasil yang sama karena H operasi mengubah status murni Zero dan status murni One menjadi status superposisi yang sama.

Catatan

Untuk melihat bagaimana hasil superposisi bervariasi dalam distribusi tembakan, gerakkan penggeser di Copilot untuk Microsoft Quantum dan tingkatkan jumlah tembakan.

Gelisahkan dua qubit

Kubit yang terjerat berkorelasi sehingga tidak dapat dijelaskan secara independen satu sama lain. Ketika Anda mengukur status satu kubit terjerat, Anda juga tahu keadaan kubit lainnya tanpa mengukurnya. Tutorial ini menggunakan contoh dengan dua qubit terjerat, tetapi Anda juga dapat menjerat tiga atau lebih qubit.

Untuk membuat status terjerat, gunakan Q#CNOT operasi, atau Controlled-NOT. Ketika Anda menerapkan CNOT ke dua qubit, satu qubit adalah qubit kontrol dan yang lainnya adalah qubit target. Jika status qubit kontrol adalah One, maka CNOT operasi membalik status qubit target. Jika tidak, CNOT tidak melakukan apa pun untuk qubit.

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

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

Jalankan program dan lihat output. Hasil Anda sedikit berbeda setiap kali Anda menjalankan program.

Q1 - Zeros: 502
Q1 - Ones: 498
Q2 - Zeros: 502
Q2 - Ones: 498

Statistik qubit pertama masih menunjukkan kemungkinan 50% untuk mengukur menjadi One atau Zero, namun, sekarang hasil pengukuran qubit kedua tidak selalu menjadi Zero. Setiap qubit memiliki jumlah Zero hasil dan One hasil yang sama. Hasil pengukuran untuk kubit kedua selalu sama dengan hasil untuk qubit pertama karena dua qubit terjerat. Jika kubit pertama diukur menjadi Zero, maka kubit yang terjerat juga harus Zero. Jika kubit pertama diukur menjadi One, maka kubit yang terjerat juga harus One.

Prasyarat

Untuk mengembangkan dan menjalankan sampel kode di lingkungan pengembangan lokal Anda, instal alat berikut:

• Versi terbaru Visual Studio Code (VS Code) atau buka VS Code untuk Web.
• Versi terbaru ekstensi Microsoft Quantum Development Kit (QDK). Untuk detail penginstalan, lihat Menyiapkan ekstensi QDK.

Membuat file baru Q#

1. Di Visual Studio Code, buka menu File dan pilih File Teks Baru untuk membuat file baru.
2. Simpan file sebagai CreateBellStates.qs. File ini adalah tempat Anda menulis Q# kode untuk program Anda.

Menginisialisasi qubit ke status yang diketahui

Langkah pertama adalah menentukan Q# operasi yang menginisialisasi qubit ke status klasik yang diinginkan, baik 0 atau 1. Operasi ini mengukur qubit dalam status kuantum umum, yang mengembalikan Q#Result nilai jenis baik Zero atau One. Jika hasil pengukuran berbeda dari status yang diinginkan, maka operasi membalikkan status sehingga operasi mengembalikan status yang diinginkan 100% dari waktu.

Buka CreateBellStates.qs dan salin kode berikut:

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

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

Berikut adalah deskripsi terperinci tentang cara SetQubitState kerja operasi:

1. Mengambil dua parameter: Result parameter jenis bernama desired yang mewakili status yang diinginkan agar qubit berada di (Zero atau One), dan Qubit parameter jenis.
2. Melakukan operasi pengukuran, M, yang mengukur status qubit (Zero atau One) dan membandingkan hasilnya dengan nilai yang Anda berikan untuk desired.
3. Jika hasil pengukuran tidak cocok dengan nilai untuk desired, maka X operasi diterapkan ke qubit. Operasi ini membalikkan status qubit sehingga probabilitas pengukuran untuk Zero dan One dibalik.

Tulis operasi uji untuk menguji keadaan Bell

Untuk memanggil SetQubitState operasi dalam program Anda Q# , 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, variabel count dan initial masing-masing diatur ke 1000 dan One. Ini menginisialisasi qubit pertama ke One dan mengukur setiap qubit 1000 kali.

Operasi Main melakukan tindakan berikut:

1. Mengatur variabel untuk jumlah bidikan (count) dan status kubit awal (One).
2. Memanggil pernyataan use untuk menginisialisasi dua qubit.
3. Mengulangi percobaan sebanyak count kali.
4. Dalam perulangan, panggilan SetQubitState untuk mengatur nilai yang ditentukan initial pada qubit pertama, lalu memanggil SetQubitState lagi untuk mengatur qubit kedua ke Zero status.
5. Dalam perulangan, operasi M diterapkan untuk melakukan pengukuran pada setiap qubit, lalu menyimpan jumlah hasil pengukuran untuk setiap qubit yang mengembalikan One.
6. Setelah perulangan selesai, panggil SetQubitState lagi untuk mengatur ulang qubit ke status yang diketahui (Zero). Anda harus mengatur ulang kubit yang Anda alokasikan dengan use pernyataan .
7. Panggil fungsi Message untuk menampilkan hasil Anda di konsol.

Menjalankan kode

Sebelum Anda menulis kode untuk superposisi dan entanglement, lakukan pengujian pada program Anda saat ini agar dapat melihat inisialisasi dan pengukuran kubit.

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

File Anda CreateBellStates.qs sekarang terlihat seperti ini:

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

Untuk menjalankan program, pilih perintah Jalankan dari lensa kode yang mendahului Main operasi, atau masukkan Ctrl + F5. Program menjalankan Main operasi pada simulator default.

Output Anda muncul di konsol debug.

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

Program Anda belum memodifikasi status qubit, sehingga pengukuran qubit pertama selalu mengembalikan One, dan qubit kedua selalu mengembalikan Zero.

Jika Anda mengubah nilai menjadi initialZero dan menjalankan program lagi, maka qubit pertama juga selalu mengembalikan Zero.

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

Menempatkan qubit ke dalam status superposisi

Saat ini, qubit dalam program Anda dalam keadaan klasik, baik 1 atau 0, seperti bit pada komputer biasa. Untuk menjerat qubit, Anda harus terlebih dahulu menempatkan salah satu qubit ke dalam status superposisi yang sama. Pengukuran qubit dalam keadaan superposisi yang setara memiliki 50% kemungkinan kembali Zero dan 50% kemungkinan mengembalikan One.

Untuk menempatkan qubit ke dalam status superposisi, gunakan Q#Hoperasi , atau Hadamard, . Operasi H mengonversi qubit yang berada dalam status Zero atau One murni menjadi status yang setengah jalan antara Zero dan One.

Ubah kode Anda pada operasi Main. Reset nilai awal ke One dan sisipkan 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); 
        ...

Jalankan program Anda lagi. Karena qubit pertama berada dalam superposisi yang sama ketika Anda mengukurnya, Anda mendekati hasil 50/50 untuk Zero dan One. Misalnya, output Anda terlihat mirip dengan ini:

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

Setiap kali Anda menjalankan program, hasil untuk qubit pertama sedikit bervariasi, tetapi hampir 50% One dan 50% Zero, sementara hasil untuk kubit kedua masih selalu Zero.

Inisialisasi qubit pertama ke Zero alih-alih One dan jalankan program lagi. Anda mendapatkan hasil yang sama karena H operasi mengubah status murni Zero dan status murni One menjadi status superposisi yang sama.

Gelisahkan dua qubit

Kubit yang terjerat berkorelasi sehingga tidak dapat dijelaskan secara independen satu sama lain. Ketika Anda mengukur status satu kubit terjerat, Anda juga tahu keadaan kubit lainnya tanpa mengukurnya. Tutorial ini menggunakan contoh dengan dua qubit terjerat, tetapi Anda juga dapat menjerat tiga atau lebih qubit.

Untuk membuat status terjerat, gunakan Q#CNOT operasi, atau Controlled-NOT. Ketika Anda menerapkan CNOT ke dua qubit, satu qubit adalah qubit kontrol dan yang lainnya adalah qubit target. Jika status qubit kontrol adalah One, maka CNOT operasi membalik status qubit target. Jika tidak, CNOT tidak melakukan apa pun untuk qubit.

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

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

Jalankan program dan lihat output. Hasil Anda sedikit berbeda setiap kali Anda menjalankan program.

Q1 - Zeros: 502
Q1 - Ones: 498
Q2 - Zeros: 502
Q2 - Ones: 498

Statistik qubit pertama masih menunjukkan kemungkinan 50% untuk mengukur menjadi One atau Zero, namun, sekarang hasil pengukuran qubit kedua tidak selalu menjadi Zero. Setiap qubit memiliki jumlah Zero hasil dan One hasil yang sama. Hasil pengukuran untuk kubit kedua selalu sama dengan hasil untuk qubit pertama karena dua qubit terjerat. Jika kubit pertama diukur menjadi Zero, maka kubit yang terjerat juga harus Zero. Jika kubit pertama diukur menjadi One, maka kubit yang terjerat juga harus One.

Buat histogram frekuensi

Untuk memplot histogram frekuensi yang menunjukkan distribusi hasil saat Anda menjalankan program beberapa kali, selesaikan langkah-langkah berikut:

1. Buka file Anda CreateBellStates.qs di Visual Studio Code.

2. Buka menu Tampilan dan pilih Palet Perintah.

3. Masukkan histogram untuk memunculkan opsi QDK: Jalankan file dan tampilkan histogram . Atau, pilih perintah Histogram dari opsi Code Lens yang mendahului operasi Main. Kemudian, masukkan sejumlah bidikan (misalnya, 100). Histogram Q# terbuka di tab baru.

   Setiap bilah dalam histogram sesuai dengan kemungkinan hasil ketika sirkuit entanglemen berjalan 1000 kali. Tinggi batang mewakili berapa kali hasil terjadi. Misalnya, histogram berikut menunjukkan distribusi dengan 50 hasil unik. Perhatikan bahwa untuk setiap hasil, hasil pengukuran untuk qubit pertama dan kedua selalu sama.

   

   Kiat

   Untuk memperbesar histogram, gunakan roda gulir mouse atau gerakan trackpad. Untuk menggeser bagan saat Anda sedang memperbesar, tahan Alt sambil menggulir.

4. Pilih bilah untuk menampilkan persentase total bidikan yang menghasilkan hasil tersebut.

5. Pilih ikon pengaturan di kiri atas untuk menampilkan opsi visualisasi.

   

6. Jalankan kode lagi, tetapi kali ini dengan 1000 bidikan. Ketika jumlah bidikan meningkat, distribusi hasil mendekati distribusi normal.

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.
• Kata Quantum adalah tutorial belajar mandiri dan latihan pemrograman yang mengajarkan elemen komputasi kuantum dan pemrograman kuantum secara bersamaan.